src

src/wcp-web/src/main/java/com/farm/wcp/controller/AIController.java

@@ -0,0 +1,407 @@
+//AI1·模块
+// 定义包名，该控制器类位于 com.farm.wcp.controller 包下
+package com.farm.wcp.controller;
+
+// 导入 java.util 包下的相关类，用于处理集合和日期
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+// 导入 javax.annotation 包下的 Resource 注解，用于资源注入
+import javax.annotation.Resource;
+// 导入 javax.servlet.http 包下的 HttpServletRequest 和 HttpSession 类，用于处理 HTTP 请求和会话
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+
+// 导入 org.apache.commons.lang 包下的 StringUtils 类，用于字符串处理
+import org.apache.commons.lang.StringUtils;
+// 导入 org.apache.log4j 包下的 Logger 类，用于日志记录
+import org.apache.log4j.Logger;
+// 导入 org.jsoup 包下的相关类，用于解析 HTML
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+// 导入 org.springframework 包下的相关注解和类，用于 Spring MVC 开发
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 com.farm.core 包下的相关类，用于用户认证、页面视图和 SQL 结果处理
+import com.farm.core.auth.domain.LoginUser;
+import com.farm.core.page.ViewMode;
+import com.farm.core.sql.result.DataResult;
+// 导入 com.farm.core.time 包下的 TimeTool 类，用于时间处理
+import com.farm.core.time.TimeTool;
+// 导入 com.farm.doc 包下的相关接口，用于文档索引、管理和类型处理
+import com.farm.doc.server.FarmDocIndexInter;
+import com.farm.doc.server.FarmDocManagerInter;
+import com.farm.doc.server.FarmDocTypeInter;
+// 导入 com.farm.doc.util 包下的 HtmlUtils 类，用于 HTML 处理
+import com.farm.doc.util.HtmlUtils;
+// 导入 com.farm.llm.utils 包下的 LlmMessage 类及其内部枚举 M_TYPE，用于处理大语言模型消息
+import com.farm.llm.utils.LlmMessage;
+import com.farm.llm.utils.LlmMessage.M_TYPE;
+// 导入 com.farm.parameter 包下的 FarmParameterService 类，用于获取系统参数
+import com.farm.parameter.FarmParameterService;
+// 导入 com.farm.tex 包下的相关类，用于 AI 问答和消息处理
+import com.farm.tex.AiQuestor;
+import com.farm.tex.domainex.AiQuestorMessage;
+import com.farm.tex.domainex.AiQuestorMessage.MessageState;
+// 导入 com.farm.wcp.util 包下的相关类，用于即时通讯历史记录和主题处理
+import com.farm.wcp.util.ImHistory;
+import com.farm.wcp.util.ThemesUtil;
+// 导入 com.farm.web 包下的 WebUtils 类，用于 Web 相关工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 智能对话服务控制器类
+ *
+ * @author wangdogn
+ */
+// 定义请求映射的根路径为 /aiweb
+@RequestMapping("/aiweb")
+// 标记该类为 Spring MVC 控制器
+@Controller
+// 继承 WebUtils 类，获取 Web 相关工具方法
+public class AIController extends WebUtils {
+
+	// 定义日志记录器，用于记录该类的日志信息
+	private static final Logger log = Logger.getLogger(AIController.class);
+	// 使用 @Resource 注解注入 FarmDocIndexInter 接口的实现类实例
+	@Resource
+	private FarmDocIndexInter farmDocIndexManagerImpl;
+	// 使用 @Resource 注解注入 FarmDocTypeInter 接口的实现类实例
+	@Resource
+	private FarmDocTypeInter farmDocTypeManagerImpl;
+	// 使用 @Resource 注解注入 FarmDocManagerInter 接口的实现类实例
+	@Resource
+	private FarmDocManagerImpl;
+
+	/**
+	 * 获取主题路径
+	 *
+	 * @return 主题路径
+	 */
+	public static String getThemePath() {
+		// 从系统参数中获取主题路径
+		return FarmParameterService.getInstance().getParameter("config.sys.web.themes.path");
+	}
+
+	/**
+	 * 独立的 AI 对话页面
+	 *
+	 * @param docid      文档 ID
+	 * @param actiontype 操作类型
+	 * @param session    HTTP 会话
+	 * @param request    HTTP 请求
+	 * @return 模型视图对象
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 定义请求映射，处理 GET 请求，路径为 /PubAiChat
+	@RequestMapping(value = "/PubAiChat", method = RequestMethod.GET)
+	public ModelAndView aiChat(String docid, String actiontype, HttpSession session, HttpServletRequest request)
+			throws Exception {
+		try {
+			// 返回 AI 对话页面的模型视图
+			return ViewMode.getInstance().returnModelAndView("web-simple/aichat/aiChat");
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回错误页面的模型视图
+			return ViewMode.getInstance().setError(e.toString())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+
+	/**
+	 * 发送消息，并接收回复
+	 *
+	 * @param message  用户发送的消息
+	 * @param session  HTTP 会话
+	 * @param request  HTTP 请求
+	 * @return 包含回复消息的 Map 对象
+	 */
+	// 定义请求映射，路径为 /PubSendmgs
+	@RequestMapping("/PubSendmgs")
+	// 将返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> StatCommitTestDate(String message, HttpSession session, HttpServletRequest request) {
+		// 初始化回复消息为空
+		String backmessage = null;
+		// 获取对话会话 ID
+		String talkSessionId = AiQuestor.getTalkSessionId(session, request);
+		// 判断是否强制登录且用户未登录
+		if (FarmParameterService.getInstance().getParameterBoolean("config.imbar.login.force")
+				&& getCurrentUser(session) == null) {
+			// 若未登录，返回必须登录的提示信息
+			return ViewMode.getInstance().putAttr("msg", "<div class='farm_wcp_ai_msg' >请&nbsp;<b>登录</b>&nbsp;账户</div>")
+					.returnObjMode();
+		}
+		// 向会话缓存中添加用户发送的消息历史记录
+		ImHistory.addMessage(session, message, message, LlmMessage.M_TYPE.USER);
+		// 获取即时通讯栏类型参数
+		if (FarmParameterService.getInstance().getParameter("config.imbar.type").equals("llm")) {
+			// 判断当前是否存在未完成的会话
+			if (AiQuestor.talking(talkSessionId) != null) {
+				// 若存在未完成的会话，返回提示信息
+				return ViewMode.getInstance()
+						.putAttr("msg", AiQuestor.talking(talkSessionId).getHtml() + "<b>(当前存在未完成的会话)</b>")
+						.returnObjMode();
+			}
+			// 进行 AI 问答，发送消息并获取回复
+			AiQuestorMessage bmessage = AiQuestor.send(message, talkSessionId, null, ImHistory.getMessages(session));
+			// 获取回复消息的 HTML 内容
+			backmessage = bmessage.getHtml();
+		}
+
+		// 判断回复消息为空、包含错误信息或即时通讯栏类型为 search
+		if (backmessage == null || backmessage.indexOf("[ERROR]") == 0
+				|| FarmParameterService.getInstance().getParameter("config.imbar.type").equals("search")) {
+			// 本地查询接口，初始化查询结果为空
+			String searchRrt = null;
+			try {
+				// 调用文档索引管理器进行搜索
+				DataResult result = farmDocIndexManagerImpl.search(message,
+						getCurrentUser(session, request) == null ? null : getCurrentUser(session, request).getId(), 1);
+				// 从搜索结果中获取知识链接
+				String linkKnows = getKnowLinksBySearchResult(result.getResultList());
+				if (StringUtils.isNotBlank(linkKnows)) {
+					// 若找到相关知识，设置查询结果为知识链接
+					searchRrt = "找到以下知识：<br/><br/>" + linkKnows;
+				} else {
+					// 若未找到相关知识，设置查询结果为提示信息
+					searchRrt = "暂未找到相关知识";
+				}
+			} catch (Exception e) {
+				// 若出现异常，打印异常堆栈信息
+				e.printStackTrace();
+			}
+
+			if (StringUtils.isBlank(backmessage)) {
+				// 若回复消息为空，将查询结果作为回复消息
+				backmessage = searchRrt;
+			} else {
+				// 若回复消息不为空，将查询结果追加到回复消息后面
+				backmessage = backmessage + "<br/>" + searchRrt;
+			}
+
+			// 创建新的 AI 问答消息对象
+			AiQuestorMessage bmessage = new AiQuestorMessage(talkSessionId);
+			// 设置消息内容
+			bmessage.setMessage(backmessage);
+			// 提交消息，标记为已完成状态
+			bmessage.submit(MessageState.COMPELET);
+			// 向会话缓存中添加回复消息的历史记录
+			ImHistory.addMessage(session, bmessage.getHtmlmsg(), HtmlUtils.HtmlRemoveTag(bmessage.getMessage()),
+					LlmMessage.M_TYPE.ASSISTANT);
+		}
+		// 将回复消息放入 Map 对象并返回
+		return ViewMode.getInstance().putAttr("msg", backmessage).returnObjMode();
+	}
+
+	/**
+	 * 加载当前消息
+	 *
+	 * @param ids     消息 ID 列表，多个 ID 用逗号分隔
+	 * @param session HTTP 会话
+	 * @param request HTTP 请求
+	 * @return 包含消息列表的 Map 对象
+	 */
+	// 定义请求映射，路径为 /PubLoadmsg
+	@RequestMapping("/PubLoadmsg")
+	// 将返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> loadmsg(String ids, HttpSession session, HttpServletRequest request) {
+		try {
+			// 初始化消息列表
+			List<AiQuestorMessage> msgs = new ArrayList<AiQuestorMessage>();
+			// 解析消息 ID 列表
+			for (String id : parseIds(ids)) {
+				// 加载指定 ID 的消息
+				AiQuestorMessage bmessage = AiQuestor.loadMessage(id);
+				// 判断消息状态是否为已完成
+				if (bmessage.getState().equals(MessageState.COMPELET)) {
+					// 若消息已完成，将消息添加到会话缓存的历史记录中
+					ImHistory.addMessage(session, bmessage.getHtmlmsg(), HtmlUtils.HtmlRemoveTag(bmessage.getMessage()),
+							LlmMessage.M_TYPE.ASSISTANT);
+					// 标记消息为已过期
+					bmessage.submit(MessageState.EXPIRE);
+				}
+				// 将消息添加到消息列表中
+				msgs.add(bmessage);
+			}
+			// 将消息列表放入 Map 对象并返回
+			return ViewMode.getInstance().putAttr("msgs", msgs).returnObjMode();
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+	}
+
+	/**
+	 * 拼接一个供 GPT 参考的知识内容，从查询结果中抽取该知识
+	 *
+	 * @param list 查询结果列表，每个元素为一个包含文档信息的 Map 对象
+	 * @return 拼接后的知识链接字符串
+	 */
+	private String getKnowLinksBySearchResult(List<Map<String, Object>> list) {
+		// 初始化知识链接字符串为空
+		String know = null;
+		// 遍历查询结果列表
+		for (Map<String, Object> node : list) {
+			// 获取文档标题
+			String title = (String) node.get("TITLE");
+			// 去除标题中的 HTML 标签和双引号
+			title = HtmlUtils.HtmlRemoveTag(title).replace("\"", "");
+			// 获取文档描述
+			String docdescribe = (String) node.get("DOCDESCRIBE");
+			// 去除文档描述中的 HTML 标签和双引号
+			docdescribe = HtmlUtils.HtmlRemoveTag(docdescribe).replace("\"", "");
+			// 获取文档 ID
+			String ID = (String) node.get("ID");
+			// 获取文档类型
+			String DOMTYPE = (String) node.get("DOMTYPE");
+			// 初始化文档链接为空
+			String url = null;
+			// 根据文档类型生成文档链接
+			if (DOMTYPE.equals("file")) {
+				url = "webdoc/view/PubFile" + ID + ".html";
+			}
+			if (DOMTYPE.equals("fqa")) {
+				url = "webquest/fqa/Pub" + ID + ".html";
+			}
+			if (!DOMTYPE.equals("fqa") && !DOMTYPE.equals("file")) {
+				url = "webdoc/view/Pub" + ID + ".html";
+			}
+			// 生成知识链接的 HTML 代码
+			String a = "<a target='_blank' title='"
+					+ docdescribe + "' href='" + url + "'>" + title + "</a><br/>";
+			if (know == null) {
+				// 若知识链接字符串为空，将当前链接作为初始值
+				know = a;
+			} else {
+				// 若知识链接字符串不为空，将当前链接追加到后面
+				know = know + a;
+			}
+		}
+		// 返回拼接后的知识链接字符串
+		return know;
+	}
+
+	/**
+	 * 清理历史消息
+	 *
+	 * @param session HTTP 会话
+	 * @param request HTTP 请求
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，路径为 /PubClear
+	@RequestMapping("/PubClear")
+	// 将返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> PubClear(HttpSession session, HttpServletRequest request) {
+		// 调用 ImHistory 类的方法清理会话缓存中的历史消息
+		ImHistory.clearMessage(session);
+		// 返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 立即停止回答
+	 *
+	 * @param ids     消息 ID 列表，多个 ID 用逗号分隔
+	 * @param session HTTP 会话
+	 * @param request HTTP 请求
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，路径为 /PubStopMsg
+	@RequestMapping("/PubStopMsg")
+	// 将返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> PubStopMsg(String ids, HttpSession session, HttpServletRequest request) {
+		try {
+			// 解析消息 ID 列表
+			for (String id : parseIds(ids)) {
+				// 调用 AiQuestorMessage 类的方法停止指定 ID 的消息回答
+				AiQuestorMessage.stop(id);
+			}
+			// 返回操作结果
+			return ViewMode.getInstance().returnObjMode();
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+	}
+
+	/**
+	 * 加载历史消息
+	 *
+	 * @param session HTTP 会话
+	 * @param request HTTP 请求
+	 * @return 包含历史消息列表的 Map 对象
+	 */
+	// 定义请求映射，路径为 /PubLoadhis
+	@RequestMapping("/PubLoadhis")
+	// 将返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> PubLoadhis(HttpSession session, HttpServletRequest request) {
+		// 从会话缓存中获取历史消息列表
+		List<LlmMessage> list = ImHistory.getMessages(session);
+		if (list.size() <= 0) {
+			// 若历史消息列表为空，获取系统配置的默认提示信息
+			String key = FarmParameterService.getInstance().getParameter("config.imbar.default.tip");
+			if (!key.trim().toLowerCase().equals("none")) {
+				// 若默认提示信息不为 none，创建新的消息对象
+				LlmMessage message = null;
+				// 获取知识库默认提示消息
+				if (message == null) {
+					message = new LlmMessage(key, M_TYPE.FUNCTIP);
+				}
+				// 将默认提示消息添加到历史消息列表中
+				list.add(message);
+			}
+		}
+		// 将历史消息列表放入 Map 对象并返回
+		return ViewMode.getInstance().putAttr("msgs", list).returnObjMode();
+	}
+
+	/**
+	 * 获取当前用户
+	 *
+	 * @param session HTTP 会话
+	 * @param request HTTP 请求
+	 * @return 当前用户对象
+	 */
+	private LoginUser getCurrentUser(HttpSession session, final HttpServletRequest request) {
+		// 初始化用户对象为空
+		LoginUser user = null;
+		// 判断会话中是否存在当前用户
+		if (getCurrentUser(session) != null) {
+			// 若存在，将其赋值给 user 对象
+			user = getCurrentUser(session);
+		} else {
+			// 若不存在，创建一个匿名用户对象
+			user = new LoginUser() {
+
+				@Override
+				public String getName() {
+					return null;
+				}
+
+				@Override
+				public String getLoginname() {
+					return null;
+				}
+
+				@Override
+				public String getId() {
+					return null;
+				}
+			};
+		}
+		// 返回当前用户对象
+		return user;
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/DocGroupController.java

@@ -0,0 +1,616 @@
+// 包声明，指定该类所属的包路径
+		package com.farm.wcp.controller;
+
+// 导入 Map 接口，用于处理键值对集合
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 RequestMethod 枚举，用于指定请求方法
+import org.springframework.web.bind.annotation.RequestMethod;
+// 导入 ResponseBody 注解，用于将方法的返回值直接写入响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DataResult 类，用于处理数据库查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入 FarmDocgroup 类，用于表示文档小组实体
+import com.farm.doc.domain.FarmDocgroup;
+// 导入 DocEntire 类，用于表示完整的文档实体
+import com.farm.doc.domain.ex.DocEntire;
+// 导入 GroupEntire 类，用于表示完整的小组实体
+import com.farm.doc.domain.ex.GroupEntire;
+// 导入 CanNoReadException 异常类，用于处理无权限读取文档的异常情况
+import com.farm.doc.exception.CanNoReadException;
+// 导入 DocNoExistException 异常类，用于处理文档不存在的异常情况
+import com.farm.doc.exception.DocNoExistException;
+// 导入 NoGroupAuthForLicenceException 异常类，用于处理无小组授权许可的异常情况
+import com.farm.doc.exception.NoGroupAuthForLicenceException;
+// 导入 FarmDocManagerInter 接口，用于文档管理操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，用于文档操作权限管理
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息管理
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 SearchType 枚举，用于指定搜索类型
+import com.farm.doc.server.FarmDocgroupManagerInter.SearchType;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 UsermessageServiceInter 接口，用于用户消息服务
+import com.farm.doc.server.UsermessageServiceInter;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 工作小组控制器类
+ *
+ * @author wangdong
+ */
+// 定义请求映射的根路径为 /webgroup
+@RequestMapping("/webgroup")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class DocGroupController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter KnowServiceImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 UsermessageServiceInter 接口的实现类实例，用于用户消息服务
+	@Resource
+	private UsermessageServiceInter usermessageServiceImpl;
+
+	/**
+	 * 进入创建小组页面
+	 *
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，包含视图信息
+	 */
+	// 映射 /add 请求路径，处理 GET 请求
+	@RequestMapping("/add")
+	public ModelAndView add(HttpSession session, HttpServletRequest request) {
+		// 返回创建小组页面的视图模型，视图路径通过 ThemesUtil 获取主题路径后拼接
+		return ViewMode.getInstance().returnModelAndView(ThemesUtil.getThemePath() + "/docgroup/editGroup");
+	}
+
+	/**
+	 * 进入修改小组页面
+	 *
+	 * @param groupid 小组 ID
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，包含小组信息和视图信息
+	 */
+	// 映射 /edit 请求路径，处理 GET 请求
+	@RequestMapping("/edit")
+	public ModelAndView edit(String groupid, HttpSession session, HttpServletRequest request) {
+		// 根据小组 ID 获取小组的完整信息
+		GroupEntire group = farmDocgroupManagerImpl.getFarmDocgroup(groupid);
+		// 将小组信息放入视图模型，并返回修改小组页面的视图模型
+		return ViewMode.getInstance().putAttr("group", group)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/docgroup/editGroup");
+	}
+
+	/**
+	 * 进入小组成员管理页面
+	 *
+	 * @param page    页码，默认为 1
+	 * @param groupid 小组 ID
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，包含成员申请信息、小组信息、成员信息和视图信息
+	 */
+	// 映射 /userMag 请求路径，处理 GET 请求
+	@RequestMapping("/userMag")
+	public ModelAndView userEdit(Integer page, String groupid, HttpSession session, HttpServletRequest request) {
+		// 如果页码为空，设置为 1
+		if (page == null) {
+			page = 1;
+		}
+		// 根据小组 ID 获取小组的完整信息
+		GroupEntire group = farmDocgroupManagerImpl.getFarmDocgroup(groupid);
+		// 获取当前成员申请信息，筛选条件为已申请（yes），未处理（none），非成员（none）
+		DataResult result = farmDocgroupManagerImpl.getGroupUser(groupid, SearchType.yes, SearchType.none,
+				SearchType.none, 1, 10);
+		// 获取成员信息，筛选条件为非申请（no），未处理（none），非成员（none）
+		DataResult users = farmDocgroupManagerImpl.getGroupUser(groupid, SearchType.no, SearchType.none,
+				SearchType.none, page, 10);
+		// 将成员申请信息、小组信息、成员信息和小组 ID 放入视图模型，并返回小组成员管理页面的视图模型
+		return ViewMode.getInstance().putAttr("applys", result).putAttr("group", group).putAttr("users", users)
+				.putAttr("groupid", groupid)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/docgroup/groupAdminConsole");
+	}
+
+	/**
+	 * 添加小组
+	 *
+	 * @param group   小组实体对象
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，根据操作结果重定向或返回错误页面
+	 */
+	// 映射 /addCommit 请求路径，处理 POST 请求（默认）
+	@RequestMapping("/addCommit")
+	public ModelAndView addCommit(FarmDocgroup group, HttpSession session) {
+		try {
+			// 如果小组存在且小组 ID 不为空但长度为 0，将小组 ID 设置为 null
+			if (group != null && group.getId() != null && group.getId().trim().length() <= 0) {
+				group.setId(null);
+			}
+			// 创建小组，传入小组名称、标签、图片、是否需要审核、小组备注和当前用户信息
+			group = farmDocgroupManagerImpl.creatDocGroup(group.getGroupname(), group.getGrouptag(),
+					group.getGroupimg(), group.getJoincheck().equals("1")? true : false, group.getGroupnote(),
+					getCurrentUser(session));
+			// 将小组 ID 放入视图模型，并重定向到小组首页
+			return ViewMode.getInstance().putAttr("id", group.getId()).returnRedirectUrl("/webgroup/PubHome.html");
+		} catch (NoGroupAuthForLicenceException e) {
+			// 如果捕获到无小组授权许可异常，重定向到小组首页
+			return ViewMode.getInstance().returnRedirectUrl("/webgroup/PubHome.html");
+		} catch (Exception e) {
+			// 如果捕获到其他异常，重定向到小组首页
+			return ViewMode.getInstance().returnRedirectUrl("/webgroup/PubHome.html");
+		}
+	}
+
+	/**
+	 * 修改小组
+	 *
+	 * @param group   小组实体对象
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，根据操作结果重定向或返回错误页面
+	 */
+	// 映射 /editCommit 请求路径，处理 POST 请求（默认）
+	@RequestMapping("/editCommit")
+	public ModelAndView editCommit(FarmDocgroup group, HttpSession session) {
+		try {
+			// 设置小组状态为 "1"
+			group.setPstate("1");
+			// 编辑小组信息，传入小组实体和当前用户信息
+			farmDocgroupManagerImpl.editFarmDocgroupEntity(group, getCurrentUser(session));
+			// 重定向到小组展示页面，带上小组 ID
+			return ViewMode.getInstance().returnRedirectUrl("/webgroup/Pubshow.do?groupid=" + group.getId());
+		} catch (Exception e) {
+			// 如果捕获到异常，打印异常堆栈信息，并重定向到小组展示页面
+			e.printStackTrace();
+			return ViewMode.getInstance().returnRedirectUrl("/webgroup/Pubshow.do?groupid=" + group.getId());
+		}
+	}
+
+	/**
+	 * 编辑小组首页
+	 *
+	 * @param groupId 小组 ID
+	 * @param docid   文档 ID
+	 * @param text    文档文本内容
+	 * @param editNote 编辑备注
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，根据操作结果重定向或返回错误页面
+	 */
+	// 映射 /homeeditCommit 请求路径，处理 POST 请求（默认）
+	@RequestMapping("/homeeditCommit")
+	public ModelAndView homeeditCommit(String groupId, String docid, String text, String editNote,
+									   HttpSession session) {
+		try {
+			// 根据文档 ID 获取文档的完整信息（此处 @SuppressWarnings 抑制了关于方法过时的警告）
+			@SuppressWarnings("deprecation")
+			DocEntire doc = farmDocManagerImpl.getDoc(docid);
+			// 设置文档的文本内容和当前用户信息
+			doc.setTexts(text, getCurrentUser(session));
+			// 编辑文档，传入文档实体、编辑备注和当前用户信息
+			farmDocManagerImpl.editDoc(doc, editNote, getCurrentUser(session));
+			// 重定向到小组展示页面，带上小组 ID
+			return ViewMode.getInstance().returnRedirectUrl("/webgroup/Pubshow.do?groupid=" + groupId);
+		} catch (Exception e) {
+			// 如果捕获到异常，打印异常堆栈信息，并重定向到小组展示页面
+			e.printStackTrace();
+			return ViewMode.getInstance().returnRedirectUrl("/webgroup/Pubshow.do?groupid=" + groupId);
+		}
+	}
+
+	/**
+	 * 进入编辑小组首页
+	 *
+	 * @param groupid 小组 ID
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，包含小组信息、文档信息和视图信息
+	 */
+	// 映射 /homeedit 请求路径，处理 GET 请求
+	@RequestMapping("/homeedit")
+	public ModelAndView homeedit(String groupid, HttpSession session, HttpServletRequest request) {
+		// 获取视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		try {
+			// 根据小组 ID 获取小组实体信息
+			FarmDocgroup group = farmDocgroupManagerImpl.getFarmDocgroupEntity(groupid);
+			// 获取小组首页文档 ID
+			String homedocid = group.getHomedocid();
+			// 根据首页文档 ID 获取文档的完整信息（此处 @SuppressWarnings 抑制了关于方法过时的警告）
+			@SuppressWarnings("deprecation")
+			DocEntire doc = farmDocManagerImpl.getDoc(homedocid);
+			// 将小组信息和文档信息放入视图模型
+			mode.putAttr("group", group).putAttr("doc", doc);
+		} catch (Exception e) {
+			// 如果捕获到异常，设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+		// 返回编辑小组首页的视图模型
+		return mode.returnModelAndView(ThemesUtil.getThemePath() + "/docgroup/editHomePage");
+	}
+
+	/**
+	 * 进入小组页面
+	 *
+	 * @param typeid  类型 ID（未使用）
+	 * @param pagenum 页码，默认为 1
+	 * @param groupid 小组 ID
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，包含文档数量、首页文档信息、小组 ID、小组信息和视图信息
+	 */
+	// 映射 /Pubshow 请求路径，处理 GET 请求
+	@RequestMapping("/Pubshow")
+	public ModelAndView show(String typeid, Integer pagenum, String groupid, HttpSession session,
+							 HttpServletRequest request) {
+		// 获取视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		// 根据小组 ID 获取小组的完整信息
+		GroupEntire docgroup = farmDocgroupManagerImpl.getFarmDocgroup(groupid);
+		// 初始化文档实体对象
+		DocEntire doc = null;
+		try {
+			// 根据小组首页文档 ID 和当前用户信息获取文档的完整信息
+			doc = farmDocManagerImpl.getDoc(docgroup.getHomedocid(), getCurrentUser(session));
+		} catch (CanNoReadException | DocNoExistException e) {
+			// 如果捕获到无权限读取或文档不存在异常，设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError("没有权限，或不存在")
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+		// 如果当前用户存在
+		if (getCurrentUser(session) != null) {
+			// 获取当前用户在小组中的权限信息，并放入视图模型
+			mode.putAttr("usergroup",
+					farmDocgroupManagerImpl.getFarmDocgroupUser(docgroup.getId(), getCurrentUser(session).getId()));
+		}
+		// 获取小组内文档数量
+		int docnum = farmDocgroupManagerImpl.getGroupDocNum(groupid);
+		// 获取小组最新知识，传入当前用户、小组 ID、数量和页码
+		mode.putAttr("docs",
+				farmDocgroupManagerImpl.getNewGroupDoc(getCurrentUser(session) == null? null : getCurrentUser(session),
+						groupid, 10, pagenum == null? 1 : pagenum));
+		// 将文档数量、首页文档信息、小组 ID、小组信息放入视图模型，并返回小组页面的视图模型
+		return mode.putAttr("docnum", docnum).putAttr("home", doc).putAttr("groupid", groupid)
+				.putAttr("docgroup", docgroup).returnModelAndView(ThemesUtil.getThemePath() + "/docgroup/groupSite");
+	}
+
+	/**
+	 * 小组栏目首页
+	 *
+	 * @param pagenum 页码，默认为 1
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，包含小组信息和视图信息
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 映射 /PubHome 请求路径，处理 GET 请求
+	@RequestMapping(value = "/PubHome", method = RequestMethod.GET)
+	public ModelAndView showDoc(Integer pagenum, HttpSession session, HttpServletRequest request) throws Exception {
+		// 如果页码为空，设置为 1
+		if (pagenum == null) {
+			pagenum = 1;
+		}
+		// 获取最热的小组信息，传入数量和页码
+		DataResult groups = farmDocgroupManagerImpl.getGroups(12, pagenum);
+		// 将小组信息放入视图模型，并返回小组栏目
+// 将最热小组信息放入视图模式的属性中，并返回小组栏目首页的视图模型
+		return ViewMode.getInstance().putAttr("groups", groups)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/docgroup/groupHome");
+	}
+
+	/**
+	 * 取消用户管理员权限
+	 *
+	 * @param groupUserId 小组用户 ID
+	 * @param session     HTTP 会话
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，处理 /wipeAdmin 路径的请求
+	@RequestMapping("/wipeAdmin")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> groupWipeAdmin(String groupUserId, HttpSession session) {
+		try {
+			// 调用服务方法，取消指定用户在小组中的管理员权限
+			farmDocgroupManagerImpl.wipeAdminFromGroup(groupUserId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 若操作成功，返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 设置为小组管理员
+	 *
+	 * @param groupUserId 小组用户 ID
+	 * @param session     HTTP 会话
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，处理 /groupSetAdmin 路径的请求
+	@RequestMapping("/groupSetAdmin")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> groupSetAdmin(String groupUserId, HttpSession session) {
+		try {
+			// 调用服务方法，将指定用户设置为小组管理员
+			farmDocgroupManagerImpl.setAdminForGroup(groupUserId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 若操作成功，返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 去除小组编辑权限
+	 *
+	 * @param groupUserId 小组用户 ID
+	 * @param session     HTTP 会话
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，处理 /groupWipeEditor 路径的请求
+	@RequestMapping("/groupWipeEditor")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> groupWipeEditor(String groupUserId, HttpSession session) {
+		try {
+			// 调用服务方法，去除指定用户在小组中的编辑权限
+			farmDocgroupManagerImpl.wipeEditorForGroup(groupUserId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 若操作成功，返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 设置小组编辑权限
+	 *
+	 * @param groupUserId 小组用户 ID
+	 * @param session     HTTP 会话
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，处理 /groupSetEditor 路径的请求
+	@RequestMapping("/groupSetEditor")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> groupSetEditor(String groupUserId, HttpSession session) {
+		try {
+			// 调用服务方法，为指定用户设置小组编辑权限
+			farmDocgroupManagerImpl.setEditorForGroup(groupUserId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 若操作成功，返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 将用户退出小组
+	 *
+	 * @param groupUserId 小组用户 ID
+	 * @param session     HTTP 会话
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，处理 /groupQuit 路径的请求
+	@RequestMapping("/groupQuit")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> groupQuit(String groupUserId, HttpSession session) {
+		try {
+			// 调用服务方法，将指定用户从小组中移除
+			farmDocgroupManagerImpl.leaveGroup(groupUserId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 若操作成功，返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 同意加入小组
+	 *
+	 * @param groupUserId 小组用户 ID
+	 * @param session     HTTP 会话
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，处理 /agreeApply 路径的请求
+	@RequestMapping("/agreeApply")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> agreeApply(String groupUserId, HttpSession session) {
+		try {
+			// 调用服务方法，同意指定用户加入小组的申请
+			farmDocgroupManagerImpl.agreeJoinApply(groupUserId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 若操作成功，返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 拒绝加入小组
+	 *
+	 * @param groupUserId 小组用户 ID
+	 * @param session     HTTP 会话
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 定义请求映射，处理 /refuseApply 路径的请求
+	@RequestMapping("/refuseApply")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> refuseApply(String groupUserId, HttpSession session) {
+		try {
+			// 调用服务方法，拒绝指定用户加入小组的申请
+			farmDocgroupManagerImpl.refuseJoinApply(groupUserId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 若出现异常，设置错误信息并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 若操作成功，返回操作结果
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 是否有小组管理员存在,通过小组管理员数量判断
+	 *
+	 * @param groupId 小组 ID
+	 * @return 包含管理员数量的 Map 对象
+	 */
+	// 定义请求映射，处理 /haveAdministratorIs 路径的请求
+	@RequestMapping("/haveAdministratorIs")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> haveAdministratorIs(String groupId) {
+		// 获取指定小组的所有管理员，并统计数量
+		int adminNum = farmDocgroupManagerImpl.getAllAdministratorByGroup(groupId).size();
+		// 将管理员数量放入视图模式的属性中，并返回操作结果
+		return ViewMode.getInstance().putAttr("adminNum", adminNum).returnObjMode();
+	}
+
+	/**
+	 * 退出小组
+	 *
+	 * @param groupId 小组 ID
+	 * @param session HTTP 会话
+	 * @return 重定向到小组展示页面的模型视图
+	 */
+	// 定义请求映射，处理 /leaveGroup 路径的请求
+	@RequestMapping("/leaveGroup")
+	public ModelAndView leaveGroup(String groupId, HttpSession session) {
+		// 调用服务方法，将当前用户从指定小组中移除
+		farmDocgroupManagerImpl.leaveGroup(groupId, getCurrentUser(session).getId());
+		// 重定向到小组展示页面
+		return ViewMode.getInstance().returnRedirectUrl("/webgroup/Pubshow.do?groupid=" + groupId);
+	}
+
+	/**
+	 * 加入小组
+	 *
+	 * @param groupId  小组 ID
+	 * @param session  HTTP 会话
+	 * @param request  HTTP 请求
+	 * @return 重定向到小组展示页面或错误页面的模型视图
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 定义请求映射，处理 /join 路径的请求
+	@RequestMapping("/join")
+	public ModelAndView joinform(String groupId, HttpSession session, HttpServletRequest request) throws Exception {
+		// 判断当前用户是否已经加入该小组
+		if (farmDocgroupManagerImpl.isJoinGroupByUser(groupId, getCurrentUser(session).getId())) {
+			// 判断当前用户的加入申请是否正在审核中
+			if (farmDocgroupManagerImpl.isAuditing(groupId, getCurrentUser(session).getId())) {
+				// 若正在审核中，设置错误信息并返回错误页面的模型视图
+				return ViewMode.getInstance().setError("正在审核中")
+						.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+			} else {
+				// 若已加入且审核通过，进入小组（此处代码未做额外处理）
+			}
+		} else {
+			// 若未加入小组
+			// 判断该小组加入是否需要审核
+			if (farmDocgroupManagerImpl.isJoinCheck(groupId)) {
+				// 若需要审核，将小组信息放入视图模式的属性中，并返回加入申请页面的模型视图
+				return ViewMode.getInstance().putAttr("group", farmDocgroupManagerImpl.getFarmDocgroupEntity(groupId))
+						.returnModelAndView(ThemesUtil.getThemePath() + "/docgroup/joinCheckForm");
+			} else {
+				// 若不需要审核，直接调用服务方法申请加入小组
+				farmDocgroupManagerImpl.applyGroup(groupId, getCurrentUser(session).getId(), "申请加入",
+						getCurrentUser(session));
+			}
+		}
+		// 将小组 ID 放入视图模式的属性中，并重定向到小组展示页面
+		return ViewMode.getInstance().putAttr("groupid", groupId).returnRedirectUrl("/webgroup/Pubshow.do");
+	}
+
+	/**
+	 * 提交小组申请
+	 *
+	 * @param groupId  小组 ID
+	 * @param message  申请消息
+	 * @param session  HTTP 会话
+	 * @param request  HTTP 请求
+	 * @return 重定向到小组展示页面、错误页面或消息提示页面的模型视图
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 定义请求映射，处理 /joincommit 路径的请求
+	@RequestMapping("/joincommit")
+	public ModelAndView joincommit(String groupId, String message, HttpSession session, HttpServletRequest request)
+			throws Exception {
+		// 判断当前用户是否已经加入该小组
+		if (farmDocgroupManagerImpl.isJoinGroupByUser(groupId, getCurrentUser(session).getId())) {
+			// 判断当前用户的加入申请是否正在审核中
+			if (farmDocgroupManagerImpl.isAuditing(groupId, getCurrentUser(session).getId())) {
+				// 若正在审核中，设置错误信息并返回错误页面的模型视图
+				return ViewMode.getInstance().setError("正在审核中")
+						.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+			} else {
+				// 若已加入且审核通过，将小组 ID 放入视图模式的属性中，并重定向到小组展示页面
+				return ViewMode.getInstance().putAttr("groupid", groupId).returnRedirectUrl("/webgroup/Pubshow.do");
+			}
+		} else {
+			// 若未加入小组，直接调用服务方法申请加入小组
+			farmDocgroupManagerImpl.applyGroup(groupId, getCurrentUser(session).getId(), message,
+					getCurrentUser(session));
+			// 设置申请提交成功的提示信息，并返回消息提示页面的模型视图
+			return ViewMode.getInstance().setError("已经提交加入请求，请等待管理员审核!")
+					.returnModelAndView(ThemesUtil.getThemePath() + "/message");
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/DocLuceneController.java

@@ -0,0 +1,234 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 URLDecoder 类，用于解码 URL 编码的字符串
+import java.net.URLDecoder;
+// 导入 List 接口，用于处理有序集合
+import java.util.List;
+// 导入 Map 接口，用于处理键值对集合
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 RequestMethod 枚举，用于指定请求方法
+import org.springframework.web.bind.annotation.RequestMethod;
+// 导入 ResponseBody 注解，用于将方法的返回值直接写入响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 UserServiceInter 接口，用于用户服务相关操作
+import com.farm.authority.service.UserServiceInter;
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DataResult 类，用于处理数据库查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入 DocBrief 类，用于表示文档的简要信息
+import com.farm.doc.domain.ex.DocBrief;
+// 导入 TypeBrief 类，用于表示类型的简要信息
+import com.farm.doc.domain.ex.TypeBrief;
+// 导入 FarmDocIndexInter 接口，用于文档索引相关操作
+import com.farm.doc.server.FarmDocIndexInter;
+// 导入 FarmDocManagerInter 接口，用于文档管理相关操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，用于文档操作权限相关操作
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocTypeInter 接口，用于文档类型相关操作
+import com.farm.doc.server.FarmDocTypeInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理相关操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理相关操作
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理相关操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 FarmParameterService 类，用于获取系统参数
+import com.farm.parameter.FarmParameterService;
+// 导入 WebHotCase 类，用于获取热门案例相关信息
+import com.farm.util.web.WebHotCase;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 检索控制器类
+ *
+ * @author wangdong
+ */
+// 定义请求映射的根路径为 /websearch
+@RequestMapping("/websearch")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class DocLuceneController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter KnowServiceImpl;
+	// 注入 FarmDocTypeInter 接口的实现类实例，用于文档类型管理
+	@Resource
+	private FarmDocTypeInter farmDocTypeManagerImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 FarmDocIndexInter 接口的实现类实例，用于文档索引管理
+	@Resource
+	private FarmDocIndexInter farmDocIndexManagerImpl;
+	// 注入 UserServiceInter 接口的实现类实例，用于用户服务
+	@Resource
+	private UserServiceInter userServiceImpl;
+
+	/**
+	 * 检索首页
+	 *
+	 * @param pagenum 页码
+	 * @param session  HTTP 会话对象
+	 * @param request  HTTP 请求对象
+	 * @return ModelAndView 对象，包含视图信息
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 映射 /PubHome 请求路径，处理 GET 请求
+	@RequestMapping(value = "/PubHome", method = RequestMethod.GET)
+	public ModelAndView show(Integer pagenum, HttpSession session, HttpServletRequest request) throws Exception {
+		// 获取视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		// 获取系统参数中配置的热门案例显示数量，并根据该数量获取热门案例列表
+		List<String> hotCase = WebHotCase.getCases(
+				Integer.valueOf(FarmParameterService.getInstance().getParameter("config.sys.webhotcase.show.num")));
+		// 获取用户可见的文档类型简要信息，"NONE" 可能是某种筛选条件
+		List<TypeBrief> typesons = farmDocTypeManagerImpl.getTypeInfos(getCurrentUser(session), "NONE");
+		// 如果当前用户存在
+		if (getCurrentUser(session) != null) {
+			// 根据当前用户 ID 获取用户所属的小组列表，数量为 100，页码为 1
+			DataResult groups = farmDocgroupManagerImpl.getGroupsByUser(getCurrentUser(session).getId(), 100, 1);
+			// 将小组列表放入视图模型的属性中
+			mode.putAttr("groups", groups.getResultList());
+		}
+		// 获取最新的 6 条知识的简要信息
+		List<DocBrief> newdocs = farmDocRunInfoImpl.getNewKnowList(6);
+		// 获取前五条置顶文档的简要信息
+		List<DocBrief> topdocs = farmDocRunInfoImpl.getPubTopDoc(2);
+		// 获取 10 条热门文档的简要信息
+		List<DocBrief> hotdocs = farmDocRunInfoImpl.getPubHotDoc(10);
+		// 将文档类型信息、最新知识信息、置顶文档信息、热门文档信息、热门案例信息放入视图模型，并返回检索首页的视图模型
+		return mode.putAttr("typesons", typesons).putAttr("docbriefs", newdocs).putAttr("topDocList", topdocs).putAttr("hotdocs", hotdocs)
+				.putAttr("hotCase", hotCase).returnModelAndView(ThemesUtil.getThemePath() + "/lucene/search");
+	}
+
+	/**
+	 * 检索
+	 *
+	 * @param word    检索词
+	 * @param pagenum 页码
+	 * @param session  HTTP 会话对象
+	 * @param request  HTTP 请求对象
+	 * @return ModelAndView 对象，包含视图信息
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 映射 /PubDo 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping(value = "/PubDo")
+	public ModelAndView search(String word, Integer pagenum, HttpSession session, HttpServletRequest request)
+			throws Exception {
+		// 初始化用户 ID 为 null
+		String userid = null;
+		// 如果当前用户存在，获取用户 ID
+		if (getCurrentUser(session) != null) {
+			userid = getCurrentUser(session).getId();
+		}
+		// 如果检索词为 null，设置为空字符串
+		if (word == null) {
+			word = "";
+		}
+		// 对检索词进行 URL 解码，使用 UTF-8 编码
+		word = URLDecoder.decode(word, "utf-8");
+		// 获取视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		// 获取系统参数中配置的热门案例显示数量，并根据该数量获取热门案例列表
+		List<String> hotCase = WebHotCase.getCases(
+				Integer.valueOf(FarmParameterService.getInstance().getParameter("config.sys.webhotcase.show.num")));
+		// 如果检索词为空或空字符串
+		if (word == null || word.isEmpty()) {
+			// 获取用户可见的文档类型简要信息，"NONE" 可能是某种筛选条件
+			List<TypeBrief> typesons = farmDocTypeManagerImpl.getTypeInfos(getCurrentUser(session), "NONE");
+			// 获取前五条置顶文档的简要信息
+			List<DocBrief> topdocs = farmDocRunInfoImpl.getPubTopDoc(2);
+			// 获取 10 条热门文档的简要信息
+			List<DocBrief> hotdocs = farmDocRunInfoImpl.getPubHotDoc(10);
+			// 设置错误信息为 "请输入检索词"，并将置顶文档信息、热门案例信息、热门文档信息、文档类型信息放入视图模型，返回检索首页的视图模型
+			return mode.setError("请输入检索词").putAttr("topDocList", topdocs).putAttr("hotCase", hotCase)
+					.putAttr("hotdocs", hotdocs).putAttr("typesons", typesons)
+					.returnModelAndView(ThemesUtil.getThemePath() + "/lucene/search");
+		}
+		try {
+			// 获取用户可见的流行文档类型简要信息
+			List<TypeBrief> types = farmDocTypeManagerImpl.getPopTypesForReadDoc(getCurrentUser(session));
+			// 根据检索词、用户 ID 和页码进行文档检索
+			DataResult result = farmDocIndexManagerImpl.search(word, userid, pagenum);
+			// 将检索结果、文档类型信息、热门案例信息、检索词放入视图模型，并返回检索结果页面的视图模型
+			return mode.putAttr("result", result).putAttr("types", types).putAttr("hotCase", hotCase)
+					.putAttr("word", word).returnModelAndView(ThemesUtil.getThemePath() + "/lucene/searchResult");
+		} catch (Exception e) {
+			// 如果捕获到异常，设置错误信息为异常信息，并返回错误页面的视图模型
+			return mode.setError(e.toString()).returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+
+	/**
+	 * 查看知识的关联知识
+	 *
+	 * @param docid   文档 ID
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return 包含关联知识信息的 Map 对象
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 映射 /PubRelationDocs 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubRelationDocs")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> relationDocs(String docid, HttpSession session, HttpServletRequest request)
+			throws Exception {
+		// 获取视图模式实例
+		ViewMode page = ViewMode.getInstance();
+		try {
+			// 根据文档 ID 获取 10 条关联文档的简要信息
+			List<DocBrief> relationdocs = farmDocIndexManagerImpl.getRelationDocs(docid, 10);
+			// 将关联文档信息放入视图模型的属性中
+			page.putAttr("RELATIONDOCS", relationdocs);
+		} catch (Exception e) {
+			// 如果捕获到异常，设置错误信息为异常信息，并返回操作结果
+			return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+		}
+		// 返回操作结果
+		return page.returnObjMode();
+	}
+}
+
+

src/wcp-web/src/main/java/com/farm/wcp/controller/DocMessageController.java

@@ -0,0 +1,238 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 List 接口，用于处理有序集合
+import java.util.List;
+// 导入 Map 接口，用于处理键值对集合
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Logger 类，用于日志记录
+import org.apache.log4j.Logger;
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ResponseBody 注解，用于将方法的返回值直接写入响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DataResult 类，用于处理数据库查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入 FarmRfDoctypeDaoInter 接口，用于文档类型关联数据访问
+import com.farm.doc.dao.FarmRfDoctypeDaoInter;
+// 导入 FarmDocmessage 类，用于表示文档消息实体
+import com.farm.doc.domain.FarmDocmessage;
+// 导入 DocBrief 类，用于表示文档的简要信息
+import com.farm.doc.domain.ex.DocBrief;
+// 导入 DocEntire 类，用于表示完整的文档实体
+import com.farm.doc.domain.ex.DocEntire;
+// 导入 FarmDocIndexInter 接口，用于文档索引相关操作
+import com.farm.doc.server.FarmDocIndexInter;
+// 导入 FarmDocManagerInter 接口，用于文档管理相关操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，用于文档操作权限相关操作
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理相关操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理相关操作
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileIndexManagerInter 接口，用于文件索引管理相关操作
+import com.farm.doc.server.FarmFileIndexManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理相关操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+// 定义请求映射的根路径为 /webdocmessage
+@RequestMapping("/webdocmessage")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class DocMessageController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter KnowServiceImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 FarmDocIndexInter 接口的实现类实例，用于文档索引管理
+	@Resource
+	private FarmDocIndexInter farmDocIndexManagerImpl;
+	// 注入 FarmRfDoctypeDaoInter 接口的实现类实例，用于文档类型关联数据访问
+	@Resource
+	private FarmRfDoctypeDaoInter farmRfDoctypeDaoImpl;
+	// 注入 FarmFileIndexManagerInter 接口的实现类实例，用于文件索引管理
+	@Resource
+	private FarmFileIndexManagerInter farmFileIndexManagerImpl;
+
+	/**
+	 * 显示文档消息页面
+	 *
+	 * @param num     页码，默认为 1
+	 * @param docid   文档 ID
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，包含视图信息
+	 */
+	// 映射 /Pubmsg 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/Pubmsg")
+	public ModelAndView docMessage(Integer num, String docid, HttpSession session, HttpServletRequest request) {
+		try {
+			// 获取 10 条热门文档的简要信息
+			List<DocBrief> hotdocs = farmDocRunInfoImpl.getPubHotDoc(10);
+			// 根据文档 ID 和当前用户获取完整的文档信息
+			DocEntire doc = farmDocManagerImpl.getDoc(docid, getCurrentUser(session));
+			// 如果页码为 null，设置为 1
+			if (num == null) {
+				num = 1;
+			}
+			// 根据文档 ID、页码和每页数量（20）获取文档消息列表
+			DataResult result = farmDocmessageManagerImpl.getMessages(docid, num, 20);
+			// 遍历文档消息列表
+			for (Map<String, Object> map : result.getResultList()) {
+				// 如果消息中包含图片 ID
+				if (map.get("IMGID") != null) {
+					// 获取图片的访问 URL，并放入消息的 map 中
+					map.put("IMGURL", farmFileManagerImpl.getFileURL(map.get("IMGID").toString()));
+				}
+				// 获取该消息的回复列表，并放入消息的 map 中
+				map.put("replys", farmDocmessageManagerImpl.getReplys(docid, map.get("ID").toString()));
+			}
+			// 将消息的时间格式化为 "yyyy-MM-dd HH:mm:ss"
+			result.runformatTime("CTIME", "yyyy-MM-dd HH:mm:ss");
+			// 将文档信息、热门文档信息、文档消息列表放入视图模型，并返回文档消息页面的视图模型
+			return ViewMode.getInstance().putAttr("doc", doc).putAttr("hotdocs", hotdocs).putAttr("result", result)
+					.returnModelAndView(ThemesUtil.getThemePath() + "/know/docMessage");
+		} catch (Exception e) {
+			// 如果捕获到异常，设置错误信息为异常信息，并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+
+	/**
+	 * 添加文档消息
+	 *
+	 * @param docid   文档 ID
+	 * @param content 消息内容
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，重定向到文档消息页面
+	 */
+	// 映射 /addmsg 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/addmsg")
+	public ModelAndView addMessage(String docid, String content, HttpSession session, HttpServletRequest request) {
+		try {
+			// 调用服务方法发送文档消息，消息类型为 "知识评论"，操作类型为 "评论"
+			farmDocmessageManagerImpl.sendAnswering(content, "知识评论", "评论", docid, getCurrentUser(session));
+			// 将文档 ID 放入视图模型，并重定向到文档消息页面
+			return ViewMode.getInstance().putAttr("docid", docid).returnRedirectUrl("/webdocmessage/Pubmsg.do");
+		} catch (Exception e) {
+			// 如果捕获到异常，设置错误信息为异常信息，并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+
+	/**
+	 * 赞同文档消息
+	 *
+	 * @param id      文档消息 ID
+	 * @param session HTTP 会话对象
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 映射 /approveOf 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/approveOf")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> approveOf(String id, HttpSession session) {
+		try {
+			// 调用服务方法对指定文档消息表示赞同
+			FarmDocmessage farmDocmessage = farmDocmessageManagerImpl.approveOf(id, getCurrentUser(session));
+			// 将处理后的文档消息放入视图模型，并返回操作结果
+			return ViewMode.getInstance().putAttr("farmDocmessage", farmDocmessage).returnObjMode();
+		} catch (Exception e) {
+			// 如果捕获到异常，返回操作结果（不包含错误信息）
+			return ViewMode.getInstance().returnObjMode();
+		}
+	}
+
+	/**
+	 * 反对文档消息
+	 *
+	 * @param id      文档消息 ID
+	 * @param session HTTP 会话对象
+	 * @return 包含操作结果的 Map 对象
+	 */
+	// 映射 /oppose 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/oppose")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> oppose(String id, HttpSession session) {
+		try {
+			// 调用服务方法对指定文档消息表示反对
+			FarmDocmessage farmDocmessage = farmDocmessageManagerImpl.oppose(id, getCurrentUser(session));
+			// 将处理后的文档消息放入视图模型，并返回操作结果
+			return ViewMode.getInstance().putAttr("farmDocmessage", farmDocmessage).returnObjMode();
+		} catch (Exception e) {
+			// 如果捕获到异常，返回操作结果（不包含错误信息）
+			return ViewMode.getInstance().returnObjMode();
+		}
+	}
+
+	/**
+	 * 回复文档消息
+	 *
+	 * @param farmDocmessage 文档消息实体
+	 * @param session        HTTP 会话对象
+	 * @return ModelAndView 对象，重定向到文档消息页面
+	 */
+	// 映射 /reply 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/reply")
+	public ModelAndView reply(FarmDocmessage farmDocmessage, HttpSession session) {
+		try {
+			// 调用服务方法回复指定的文档消息
+			farmDocmessageManagerImpl.reply(farmDocmessage.getContent(), farmDocmessage.getAppid(),
+					farmDocmessage.getId(), getCurrentUser(session));
+			// 将文档 ID（消息所属的文档 ID）放入视图模型，并重定向到文档消息页面
+			return ViewMode.getInstance().putAttr("docid", farmDocmessage.getAppid())
+					.returnRedirectUrl("/webdocmessage/Pubmsg.do");
+		} catch (Exception e) {
+			// 如果捕获到异常，设置错误信息为异常信息，并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/DocStatController.java

@@ -0,0 +1,172 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 Map 接口，用于处理键值对集合
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 RequestMethod 枚举，用于指定请求方法
+import org.springframework.web.bind.annotation.RequestMethod;
+// 导入 ResponseBody 注解，用于将方法的返回值直接写入响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 User 类，用于表示用户实体
+import com.farm.authority.domain.User;
+// 导入 UserServiceInter 接口，用于用户服务相关操作
+import com.farm.authority.service.UserServiceInter;
+// 导入 LoginUser 类，用于表示登录用户
+import com.farm.core.auth.domain.LoginUser;
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DataResult 类，用于处理数据库查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入 FarmDocManagerInter 接口，用于文档管理相关操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，用于文档操作权限相关操作
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理相关操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理相关操作
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理相关操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 工作小组统计控制器类
+ *
+ * @author wangdong
+ */
+// 定义请求映射的根路径为 /webstat
+@RequestMapping("/webstat")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class DocStatController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter KnowServiceImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 UserServiceInter 接口的实现类实例，用于用户服务
+	@Resource
+	private UserServiceInter userServiceImpl;
+
+	/**
+	 * 统计首页
+	 *
+	 * @param pagenum 页码
+	 * @param session  HTTP 会话对象
+	 * @param request  HTTP 请求对象
+	 * @return ModelAndView 对象，包含视图信息
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 映射 /PubHome 请求路径，处理 GET 请求
+	@RequestMapping(value = "/PubHome", method = RequestMethod.GET)
+	public ModelAndView show(Integer pagenum, HttpSession session, HttpServletRequest request) throws Exception {
+		// 获取视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		// 获取好评用户排名数据，数量为 10 条
+		DataResult goodUsers = farmDocRunInfoImpl.getStatGoodUsers(10);
+		// 将好评用户排名数据放入视图模型的属性中
+		mode.putAttr("goodUsers", goodUsers);
+		// 获取好评小组排名数据，数量为 10 条
+		DataResult goodGroups = farmDocRunInfoImpl.getStatGoodGroups(10);
+		// 将好评小组排名数据放入视图模型的属性中
+		mode.putAttr("goodGroups", goodGroups);
+		// 获取用户发布排名数据，数量为 10 条
+		DataResult manyUsers = farmDocRunInfoImpl.getStatMostUsers(10);
+		// 将用户发布排名数据放入视图模型的属性中
+		mode.putAttr("manyUsers", manyUsers);
+		// 获取好评文章排名数据，数量为 10 条
+		DataResult goodDocs = farmDocRunInfoImpl.getStatGoodDocs(10);
+		// 将好评文章排名数据放入视图模型的属性中
+		mode.putAttr("goodDocs", goodDocs);
+		// 获取待完善文章排名数据，数量为 10 条
+		DataResult badDocs = farmDocRunInfoImpl.getStatBadDocs(10);
+		// 将待完善文章排名数据放入视图模型的属性中
+		mode.putAttr("badDocs", badDocs);
+		// 获取当前登录用户信息
+		LoginUser luser = getCurrentUser(session);
+		// 如果当前用户存在
+		if (luser != null) {
+			// 根据用户 ID 获取用户实体信息
+			User user = userServiceImpl.getUserEntity(luser.getId());
+			// 获取用户使用量分析数据
+			DataResult users = farmDocRunInfoImpl.getStatUser(user);
+			// 如果用户的头像 ID 不为空且长度大于 0
+			if (user.getImgid() != null && user.getImgid().trim().length() > 0) {
+				// 获取用户头像的文件 URL，并放入视图模型的属性中
+				mode.putAttr("photourl", farmFileManagerImpl.getFileURL(user.getImgid()));
+			}
+			// 将用户使用量分析数据放入视图模型的属性中
+			mode.putAttr("users", users);
+		}
+		// 返回统计首页的视图模型，视图路径通过 ThemesUtil 获取主题路径后拼接
+		return mode.returnModelAndView(ThemesUtil.getThemePath() + "/statis/heros");
+	}
+
+	/**
+	 * 获取所有统计数据（用于 wcp 使用量分析）
+	 *
+	 * @param session HTTP 会话对象
+	 * @param id      未使用的参数（可能预留）
+	 * @return 包含统计数据的 Map 对象
+	 */
+	// 映射 /PubStatAll 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubStatAll")
+	// 将方法返回值直接作为响应体返回
+	@ResponseBody
+	public Map<String, Object> statAll(HttpSession session, String id) {
+		// 获取视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		// 用于存储 wcp 使用量分析的统计数据
+		Map<String, Object> nums;
+		try {
+			// 获取按天统计的使用量数据
+			nums = farmDocRunInfoImpl.getStatNumForDay();
+			// 将统计数据放入视图模型的属性中
+			mode.putAttr("nums", nums);
+		} catch (Exception e) {
+			// 如果捕获到异常，返回操作结果（不包含错误信息）
+			return mode.returnObjMode();
+		}
+		// 返回操作结果
+		return mode.returnObjMode();
+	}
+}

src/wcp-web/src/main/java/com/farm/wcp/controller/DocTypeController.java

@@ -0,0 +1,133 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 List 接口，用于处理有序集合
+import java.util.List;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 PathVariable 注解，用于从 URL 路径中提取参数
+import org.springframework.web.bind.annotation.PathVariable;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 RequestMethod 枚举，用于指定请求方法
+import org.springframework.web.bind.annotation.RequestMethod;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 LoginUser 类，用于表示登录用户
+import com.farm.core.auth.domain.LoginUser;
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DataResult 类，用于处理数据库查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入 FarmDoctype 类，用于表示文档类型实体
+import com.farm.doc.domain.FarmDoctype;
+// 导入 TypeBrief 类，用于表示类型的简要信息
+import com.farm.doc.domain.ex.TypeBrief;
+// 导入 FarmDocManagerInter 接口，用于文档管理相关操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，用于文档操作权限相关操作
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocTypeInter 接口，用于文档类型相关操作
+import com.farm.doc.server.FarmDocTypeInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理相关操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理相关操作
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理相关操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+// 定义请求映射的根路径为 /webtype
+@RequestMapping("/webtype")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class DocTypeController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter KnowServiceImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 FarmDocTypeInter 接口的实现类实例，用于文档类型管理
+	@Resource
+	private FarmDocTypeInter farmDocTypeManagerImpl;
+
+	/**
+	 * 分类首页
+	 *
+	 * @param typeid   类型 ID，从 URL 路径中获取
+	 * @param session  HTTP 会话对象
+	 * @param request  HTTP 请求对象
+	 * @param pagenum  页码，从 URL 路径中获取
+	 * @return ModelAndView 对象，包含视图信息
+	 * @throws Exception 可能抛出的异常
+	 */
+	// 映射 /view{typeid}/Pub{pagesize} 请求路径，处理 GET 请求，其中 {typeid} 和 {pagesize} 是路径参数
+	@RequestMapping(value = "/view{typeid}/Pub{pagesize}", method = RequestMethod.GET)
+	public ModelAndView types(@PathVariable("typeid") String typeid, HttpSession session, HttpServletRequest request,
+							  @PathVariable("pagesize") Integer pagenum) throws Exception {
+		// 获取视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		// 如果类型 ID 为空或空字符串
+		if (typeid == null || typeid.isEmpty()) {
+			// 设置类型 ID 为 "NONE"
+			typeid = "NONE";
+		} else {
+			// 根据类型 ID 获取类型信息，并放入视图模型的属性中
+			mode.putAttr("type", farmDocTypeManagerImpl.getType(typeid));
+		}
+		// 如果页码为 null
+		if (pagenum == null) {
+			// 设置页码为 1
+			pagenum = 1;
+		}
+		// 获取当前登录用户信息
+		LoginUser user = getCurrentUser(session);
+		// 将类型 ID 放入视图模型的属性中
+		mode.putAttr("typeid", typeid);
+		// 获取指定类型的所有父类型路径
+		List<FarmDoctype> typepath = farmDocTypeManagerImpl.getTypeAllParent(typeid);
+		// 获取用户可见的流行文档类型简要信息
+		List<TypeBrief> types = farmDocTypeManagerImpl.getPopTypesForReadDoc(getCurrentUser(session));
+		// 获取用户可见的指定类型的子类型简要信息
+		List<TypeBrief> typesons = farmDocTypeManagerImpl.getTypeInfos(getCurrentUser(session), typeid);
+		// 根据用户、类型 ID、数量（10）和页码获取该类型下的文档列表
+		DataResult docs = farmDocTypeManagerImpl.getTypeDocs(user, typeid, 10, pagenum);
+		// 将流行文档类型信息、子类型信息、类型路径信息、文档列表信息放入视图模型，并返回分类首页的视图模型
+		return mode.putAttr("types", types).putAttr("typesons", typesons).putAttr("typepath", typepath).putAttr("docs", docs)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/type/type");
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/FrameController.java

@@ -0,0 +1,184 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 Method 类，用于反射获取方法信息
+import java.lang.reflect.Method;
+// 导入 ArrayList 类，用于创建可变大小的列表
+import java.util.ArrayList;
+// 导入 HashMap 类，用于创建键值对集合
+import java.util.HashMap;
+// 导入 List 接口，用于处理有序集合
+import java.util.List;
+// 导入 Map 接口，用于处理键值对集合
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 ServletContext 接口，用于获取 Servlet 上下文信息
+import javax.servlet.ServletContext;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Logger 类，用于日志记录
+import org.apache.log4j.Logger;
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ResponseBody 注解，用于将方法的返回值直接写入响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 WebApplicationContext 接口，用于访问 Spring 应用上下文
+import org.springframework.web.context.WebApplicationContext;
+// 导入 WebApplicationContextUtils 类，用于获取 Web 应用上下文
+import org.springframework.web.context.support.WebApplicationContextUtils;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DataQuery 类，可能用于数据库查询操作
+import com.farm.core.sql.query.DataQuery;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+// 导入 EasyUiTreeNode 类，用于表示 EasyUI 树节点
+import com.farm.web.easyui.EasyUiTreeNode;
+// 导入 EasyUiUtils 类，用于处理 EasyUI 相关的工具方法
+import com.farm.web.easyui.EasyUiUtils;
+
+// 定义请求映射的根路径为 /frame
+@RequestMapping("/frame")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class FrameController extends WebUtils {
+	// 创建 Logger 实例，用于记录该类的日志信息
+	private final static Logger log = Logger.getLogger(FrameController.class);
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+
+	/**
+	 * 访问系统框架首页
+	 *
+	 * @param request HTTP 请求对象
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，包含用户菜单信息和视图信息
+	 */
+	// 映射 /index 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/index")
+	public ModelAndView index(HttpServletRequest request, HttpSession session) {
+		// 获取当前用户的菜单信息，并将其放入视图模型的属性中，然后返回框架首页的视图模型
+		return ViewMode.getInstance().putAttr("menus", getCurrentUserMenus(session)).returnModelAndView("frame/frame");
+	}
+
+	/**
+	 * 访问系统主页
+	 *
+	 * @param request HTTP 请求对象
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，包含统计信息和视图信息
+	 */
+	// 映射 /home 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/home")
+	public ModelAndView home(HttpServletRequest request, HttpSession session) {
+		// 用于存储统计信息的 Map 对象
+		Map<String, Integer> map = null;
+		try {
+			// 获取统计信息
+			map = farmDocRunInfoImpl.getStatNum();
+		} catch (Exception e) {
+			// 如果获取统计信息失败，创建一个空的 HashMap
+			map = new HashMap<>();
+			// 记录错误信息到日志中
+			log.error(e.getMessage());
+		}
+		// 将统计信息放入视图模型的属性中，并返回系统主页的视图模型
+		return ViewMode.getInstance().putAttr("STAT", map).returnModelAndView("frame/home");
+	}
+
+	/**
+	 * 获取所有的请求映射 URL 并以 EasyUI 树节点的形式返回
+	 *
+	 * @param query   数据库查询对象（未使用）
+	 * @param request HTTP 请求对象
+	 * @return 包含所有请求映射 URL 的 EasyUI 树节点列表
+	 */
+	// 映射 /service 请求路径，处理默认请求（未指定方法，通常为 GET），并将返回值作为响应体返回
+	@SuppressWarnings("unchecked")
+	@RequestMapping("/service")
+	@ResponseBody
+	public List<EasyUiTreeNode> allUrl(DataQuery query, HttpServletRequest request) {
+		// 记录日志，提示正式系统请关闭该服务
+		log.info("正式系统请 关闭该服务");
+		// 获取 Servlet 上下文对象
+		ServletContext servletContext = request.getSession().getServletContext();
+		// 获取 Web 应用上下文对象
+		WebApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
+		// 创建一个用于存储节点信息的列表
+		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
+		// 获取所有被 @Controller 注解标记的 Bean 及其对应的映射信息
+		Map<String, Object> allRequestMappings = appContext.getBeansWithAnnotation(Controller.class);
+		// 节点序号，初始值为 1
+		int n = 1;
+		// 遍历所有被 @Controller 注解标记的 Bean
+		for (Object obj : allRequestMappings.values()) {
+			// 获取类上的 @RequestMapping 注解
+			RequestMapping classRequest = obj.getClass().getAnnotation(RequestMapping.class);
+			// 如果类上存在 @RequestMapping 注解
+			if (classRequest != null) {
+				// 封装父节点信息
+				Map<String, Object> superNode = new HashMap<String, Object>();
+				// 节点序号自增
+				int m = ++n;
+				// 设置父节点的唯一标识
+				superNode.put("SID", n);
+				// 设置父节点的父节点标识为 "none"
+				superNode.put("PID", "none");
+				// 如果类的 @RequestMapping 注解的 value 为空或长度为 0
+				if (classRequest.value() == null || classRequest.value().length == 0) {
+					// 设置父节点名称为 "NoGroup"
+					superNode.put("NA", "NoGroup");
+				} else {
+					// 设置父节点名称为类的 @RequestMapping 注解的 value 值
+					superNode.put("NA", classRequest.value()[0]);
+				}
+				// 将父节点信息添加到列表中
+				list.add(superNode);
+				// 遍历类中的所有方法
+				for (Method method : obj.getClass().getMethods()) {
+					// 获取方法上的 @RequestMapping 注解
+					RequestMapping methodRequest = method.getAnnotation(RequestMapping.class);
+					// 如果方法上存在 @RequestMapping 注解
+					if (methodRequest != null) {
+						// 封装子节点信息
+						Map<String, Object> childeNode = new HashMap<String, Object>();
+						// 节点序号自增
+						n++;
+						// 设置子节点的唯一标识
+						childeNode.put("SID", n);
+						// 设置子节点的父节点标识为父节点的序号
+						childeNode.put("PID", m);
+						// 如果类的 @RequestMapping 注解的 value 为空或长度为 0
+						if (classRequest.value() == null || classRequest.value().length == 0) {
+							// 设置子节点名称为方法的 @RequestMapping 注解的 value 值去掉 "/" 后的内容
+							childeNode.put("NA", methodRequest.value()[0].replaceAll("/", ""));
+						} else {
+							// 设置子节点名称为类的 @RequestMapping 注解的 value 值去掉 "/" 后与方法的 @RequestMapping 注解的 value 值拼接的结果
+							childeNode.put("NA",
+									classRequest.value()[0].replaceAll("/", "") + methodRequest.value()[0]);
+						}
+						// 将子节点信息添加到列表中
+						list.add(childeNode);
+					}
+				}
+			}
+		}
+		// 将列表中的节点信息格式化为 EasyUI 树节点列表，并返回
+		return (List<EasyUiTreeNode>) ViewMode.returnListObjMode(EasyUiUtils.formatAjaxTree(list, "PID", "SID", "NA"));
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/IndexController.java

@@ -0,0 +1,289 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 IOException 类，用于处理输入输出异常
+import java.io.IOException;
+// 导入 OutputStream 类，用于输出流操作
+import java.io.OutputStream;
+// 导入 URLEncoder 类，用于 URL 编码
+import java.net.URLEncoder;
+// 导入 ArrayList 类，用于创建可变大小的列表
+import java.util.ArrayList;
+// 导入 Hashtable 类，用于创建键值对集合
+import java.util.Hashtable;
+// 导入 List 接口，用于处理有序集合
+import java.util.List;
+// 导入 Map 接口，用于处理键值对集合
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpServletResponse 类，用于处理 HTTP 响应
+import javax.servlet.http.HttpServletResponse;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ResponseBody 注解，用于将方法的返回值直接写入响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DBRule 类，用于数据库查询规则
+import com.farm.core.sql.query.DBRule;
+// 导入 DBSort 类，用于数据库查询排序
+import com.farm.core.sql.query.DBSort;
+// 导入 DataQuery 类，用于数据库查询操作
+import com.farm.core.sql.query.DataQuery;
+// 导入 DataResult 类，用于处理数据库查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入 DocBrief 类，用于表示文档的简要信息
+import com.farm.doc.domain.ex.DocBrief;
+// 导入 GroupBrief 类，用于表示小组的简要信息
+import com.farm.doc.domain.ex.GroupBrief;
+// 导入 TypeBrief 类，用于表示类型的简要信息
+import com.farm.doc.domain.ex.TypeBrief;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocTypeInter 接口，用于文档类型相关操作
+import com.farm.doc.server.FarmDocTypeInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理相关操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理相关操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 FarmtopServiceInter 接口，功能不明确（从命名推测与顶部服务相关）
+import com.farm.doc.server.FarmtopServiceInter;
+// 导入 WeburlServiceInter 接口，功能不明确（从命名推测与 Web 网址服务相关）
+import com.farm.doc.server.WeburlServiceInter;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 ZxingTowDCode 类，用于处理二维码相关操作（推测）
+import com.farm.wcp.util.ZxingTowDCode;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+// 导入 BarcodeFormat 枚举，用于表示条形码格式
+import com.google.zxing.BarcodeFormat;
+// 导入 EncodeHintType 枚举，用于设置编码提示类型
+import com.google.zxing.EncodeHintType;
+// 导入 MultiFormatWriter 类，用于生成多种格式的条形码或二维码
+import com.google.zxing.MultiFormatWriter;
+// 导入 BitMatrix 类，用于表示二维矩阵（用于存储生成的条形码或二维码的数据）
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * 文件相关的控制器类
+ *
+ * @author autoCode
+ */
+// 定义请求映射的根路径为 /home
+@RequestMapping("/home")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class IndexController extends WebUtils {
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter KnowServiceImpl;
+	// 注入 FarmtopServiceInter 接口的实现类实例，用于相关顶部服务操作
+	@Resource
+	private FarmtopServiceInter farmTopServiceImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocTypeInter 接口的实现类实例，用于文档类型管理
+	@Resource
+	private FarmDocTypeInter farmDocTypeManagerImpl;
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 WeburlServiceInter 接口的实现类实例，用于相关 Web 网址服务操作
+	@Resource
+	private WeburlServiceInter weburlServiceImpl;
+
+	/**
+	 * 访问系统首页
+	 *
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，包含各种数据信息和视图信息
+	 */
+	// 映射 /Pubindex 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/Pubindex")
+	public ModelAndView index(HttpSession session) {
+		// 获取前五条置顶文档的简要信息
+		List<DocBrief> topdocs = farmDocRunInfoImpl.getPubTopDoc(5);
+		// 获取十条热门文档的简要信息
+		List<DocBrief> hotdocs = farmDocRunInfoImpl.getPubHotDoc(10);
+		// 获取六条最新知识文档的简要信息
+		List<DocBrief> newdocs = farmDocRunInfoImpl.getNewKnowList(6);
+		// 获取用户可见的流行文档类型简要信息
+		List<TypeBrief> typesons = farmDocTypeManagerImpl.getPopTypesForReadDoc(getCurrentUser(session));
+		// 获取十条最热小组的简要信息
+		List<GroupBrief> groups = farmDocgroupManagerImpl.getHotDocGroups(10, getCurrentUser(session));
+		// 将热门文档信息、最热小组信息、最新知识文档信息、文档类型信息、最新知识文档信息（重复添加，可能是笔误）、置顶文档信息放入视图模型，并返回首页的视图模型
+		return ViewMode.getInstance().putAttr("hotdocs", hotdocs).putAttr("groups", groups).putAttr("docbriefs", newdocs)
+				.putAttr("typesons", typesons).putAttr("newdocs", newdocs).putAttr("topDocList", topdocs)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/index");
+	}
+
+	/**
+	 * 访问联系方式页面
+	 *
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，返回联系方式页面的视图模型
+	 */
+	// 映射 /PubAbout 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubAbout")
+	public ModelAndView contact(HttpSession session) {
+		// 返回联系方式页面的视图模型
+		return ViewMode.getInstance().returnModelAndView(ThemesUtil.getThemePath() + "/about");
+	}
+
+	/**
+	 * 生成并展示二维码
+	 *
+	 * @param request  HTTP 请求对象
+	 * @param response HTTP 响应对象
+	 */
+	// 映射 /PubQRCode 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubQRCode")
+	public void QRCode(HttpServletRequest request, HttpServletResponse response) {
+		// 输出流对象，用于输出二维码图片数据
+		OutputStream outp = null;
+		try {
+			// 获取当前应用的上下文路径
+			String path = request.getContextPath();
+			// 构造要编码到二维码中的完整 URL
+			String text = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path
+					+ "/";
+			// 二维码图片的宽度
+			int width = 300;
+			// 二维码图片的高度
+			int height = 300;
+			// 二维码的图片格式为 gif
+			String format = "gif";
+			// 创建一个 Hashtable 用于设置编码提示信息
+			Hashtable<EncodeHintType, String> hints = new Hashtable<EncodeHintType, String>();
+			// 设置编码字符集为 utf-8
+			hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
+			// 使用 MultiFormatWriter 生成二维码的 BitMatrix 对象
+			BitMatrix bitMatrix = new MultiFormatWriter().encode(text, BarcodeFormat.QR_CODE, width, height, hints);
+			// 设置响应的内容类型为文件下载类型
+			response.setContentType("application/x-download");
+			// 给用户提供的下载文件名（这里只是一个占位符，未实际获取文件相关信息）
+			String filedisplay = "给用户提供的下载文件名";
+			// 对文件名进行 URL 编码
+			filedisplay = URLEncoder.encode(filedisplay, "UTF-8");
+			// 添加响应头，设置文件下载的相关信息
+			response.addHeader("Content-Disposition", "attachment;filename=" + filedisplay);
+			// 获取响应的输出流
+			outp = response.getOutputStream();
+			// 将生成的二维码数据写入输出流
+			ZxingTowDCode.writeToStream(bitMatrix, format, outp);
+
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+		} finally {
+			// 如果输出流不为空，关闭输出流
+			if (outp != null) {
+				try {
+					outp.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}
+	}
+
+	/**
+	 * 获取推荐服务列表
+	 *
+	 * @return 包含推荐服务信息的 List 对象
+	 */
+	// 映射 /PubrecommendServiceList 请求路径，处理默认请求（未指定方法，通常为 GET），并将返回值作为响应体返回
+	@RequestMapping("/PubrecommendServiceList")
+	@ResponseBody
+	public List<?> recommendServiceList() {
+		// 获取推荐服务的列表数据
+		List<Map<String, Object>> weburlList = weburlServiceImpl.getList();
+		// 将列表数据格式化为特定的视图模式并返回
+		return ViewMode.returnListObjMode(weburlList);
+	}
+
+	/**
+	 * 加载机构信息并返回相应视图
+	 *
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，包含机构信息和相应视图
+	 */
+	// 映射 /PubFPloadOrgs 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubFPloadOrgs")
+	public ModelAndView userInfo(HttpSession session) {
+		try {
+			// 创建一个数据库查询对象，指定页码为 1，查询字段为 "ID,NAME,PARENTID"，表名为 "alone_auth_organization"
+			DataQuery query = DataQuery.getInstance(1, "ID,NAME,PARENTID", "alone_auth_organization");
+			// 添加查询规则，筛选出 STATE 字段值为 "1" 的记录
+			query.addRule(new DBRule("STATE", "1", "="));
+			// 添加排序规则，按 SORT 字段升序排序
+			query.addSort(new DBSort("SORT", "ASC"));
+			// 执行查询并获取结果
+			DataResult result = query.search();
+			// 将查询结果放入视图模型，并返回相应的视图
+			return ViewMode.getInstance().putAttr("result", result).returnModelAndView("web/user/commons/impl/pubOrg");
+		} catch (Exception e) {
+			// 如果发生异常，设置错误信息并返回空视图
+			return ViewMode.getInstance().setError(e.toString()).returnModelAndView("");
+		}
+	}
+
+	/**
+	 * 按照名称查询知识信息
+	 *
+	 * @param knowtitle 知识标题（查询条件）
+	 * @return 包含查询结果信息的 Map 对象
+	 */
+	// 映射 /FPsearchKnow 请求路径，处理默认请求（未指定方法，通常为 GET），并将返回值作为响应体返回
+	@RequestMapping("/FPsearchKnow")
+	@ResponseBody
+	public Map<String, Object> FPsearchKnow(String knowtitle) {
+		try {
+			// 创建一个数据库查询对象，指定页码为 1，查询字段为 "TITLE,ID,DOMTYPE"，表名为 "FARM_DOC"
+			DataQuery query = DataQuery.getInstance(1, "TITLE,ID,DOMTYPE", "FARM_DOC");
+			// 如果知识标题不为空
+			if (knowtitle != null) {
+				// 添加查询规则，按标题模糊匹配
+				query.addRule(new DBRule("TITLE", knowtitle, "like"));
+			} else {
+				// 如果知识标题为空，按 ctime 字段降序排序
+				query.addSort(new DBSort("ctime", "desc"));
+			}
+			// 添加查询规则，筛选出 STATE 字段值为 "1" 的记录
+			query.addRule(new DBRule("STATE", "1", "="));
+			// 添加额外的 SQL 查询条件
+			query.addSqlRule(" and (READPOP='1' or READPOP='2')");
+			// 执行查询并获取结果
+			DataResult result = query.search();
+			// 获取查询结果列表
+			List<Map<String, Object>> list = result.getResultList();
+			// 将结果列表和列表大小放入视图模型，并返回相应的视图模式
+			return ViewMode.getInstance().putAttr("list", list).putAttr("size", list.size()).returnObjMode();
+		} catch (Exception e) {
+			// 如果发生异常，返回一个空的结果列表和大小为 0 的视图模式
+			return ViewMode.getInstance().putAttr("list", new ArrayList<Map<String, Object>>()).putAttr("size", 0)
+					.returnObjMode();
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/KnowController.java

@@ -0,0 +1,312 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 List 接口，用于处理有序集合
+import java.util.List;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 Doc 类，用于表示文档实体
+import com.farm.doc.domain.Doc;
+// 导入 FarmDoctype 类，用于表示文档类型实体
+import com.farm.doc.domain.FarmDoctype;
+// 导入 DocEntire 类，用于表示完整的文档信息
+import com.farm.doc.domain.ex.DocEntire;
+// 导入 TypeBrief 类，用于表示类型的简要信息
+import com.farm.doc.domain.ex.TypeBrief;
+// 导入 FarmDocManagerInter 接口，用于文档管理相关操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，用于文档操作权限相关操作
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 POP_TYPE 枚举，用于表示权限类型
+import com.farm.doc.server.FarmDocOperateRightInter.POP_TYPE;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocTypeInter 接口，用于文档类型相关操作
+import com.farm.doc.server.FarmDocTypeInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理相关操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理相关操作
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理相关操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 知识相关操作的控制器类
+ *
+ * @author autoCode
+ */
+// 定义请求映射的根路径为 /know
+@RequestMapping("/know")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class KnowController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter KnowServiceImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 FarmDocTypeInter 接口的实现类实例，用于文档类型管理
+	@Resource
+	private FarmDocTypeInter farmDocTypeManagerImpl;
+
+	/**
+	 * 进入创建知识页面
+	 *
+	 * @param typeid   文档类型 ID
+	 * @param groupid  文档小组 ID
+	 * @param session  HTTP 会话对象
+	 * @param request  HTTP 请求对象
+	 * @return ModelAndView 对象，包含类型信息和文档信息以及视图信息
+	 */
+	// 映射 /add 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/add")
+	public ModelAndView add(String typeid, String groupid, HttpSession session, HttpServletRequest request) {
+		// 获取当前用户可用于撰写文档的类型简要信息列表
+		List<TypeBrief> types = farmDocTypeManagerImpl.getTypesForWriteDoc(getCurrentUser(session));
+
+		// 创建一个完整的文档信息对象
+		DocEntire doce = new DocEntire();
+		// 根据类型 ID 获取文档类型信息
+		FarmDoctype doctype = farmDocTypeManagerImpl.getType(typeid);
+		// 将文档类型信息设置到完整文档信息对象中
+		doce.setType(doctype);
+
+		// 创建一个文档对象
+		Doc doc = new Doc();
+		// 设置文档所属小组 ID
+		doc.setDocgroupid(groupid);
+		// 将文档对象设置到完整文档信息对象中
+		doce.setDoc(doc);
+
+		// 将类型信息和完整文档信息放入视图模型，并返回创建知识页面的视图模型
+		return ViewMode.getInstance().putAttr("types", types).putAttr("doce", doce)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/know/creat");
+	}
+
+	/**
+	 * 进入网页输入页面
+	 *
+	 * @param typeid   文档类型 ID
+	 * @param groupid  文档小组 ID
+	 * @param session  HTTP 会话对象
+	 * @param request  HTTP 请求对象
+	 * @return ModelAndView 对象，包含类型 ID 和小组 ID 以及视图信息
+	 */
+	// 映射 /webdown 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/webdown")
+	public ModelAndView downWeb(String typeid, String groupid, HttpSession session, HttpServletRequest request) {
+		// 将类型 ID 和小组 ID 放入视图模型，并返回网页输入页面的视图模型
+		return ViewMode.getInstance().putAttr("typeid", typeid).putAttr("groupid", groupid)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/know/downWeb");
+	}
+
+	/**
+	 * 提交并下载网页创建知识
+	 *
+	 * @param url      网页 URL
+	 * @param typeid   文档类型 ID
+	 * @param groupid  文档小组 ID
+	 * @param session  HTTP 会话对象
+	 * @param request  HTTP 请求对象
+	 * @return ModelAndView 对象，包含文档信息和类型信息以及视图信息
+	 */
+	// 映射 /webDLoadDo 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/webDLoadDo")
+	public ModelAndView downWebCommit(String url, String typeid, String groupid, HttpSession session,
+									  HttpServletRequest request) {
+		try {
+			// 根据网页 URL 和当前用户信息获取完整的文档信息
+			DocEntire doc = KnowServiceImpl.getDocByWeb(url, getCurrentUser(session));
+			// 如果类型 ID 不为空且不等于 "NONE"
+			if (typeid != null && !typeid.toUpperCase().trim().equals("NONE")
+					&& !typeid.toUpperCase().trim().equals("")) {
+				// 根据类型 ID 获取文档类型信息
+				FarmDoctype doctype = farmDocTypeManagerImpl.getType(typeid);
+				// 将文档类型信息设置到完整文档信息对象中
+				doc.setType(doctype);
+			}
+			// 如果小组 ID 不为空且不等于 "NONE"
+			if (groupid != null && !groupid.toUpperCase().trim().equals("NONE")
+					&& !groupid.toUpperCase().trim().equals("")) {
+				// 设置文档所属小组 ID
+				doc.getDoc().setDocgroupid(groupid);
+			}
+			// 获取当前用户可用于撰写文档的类型简要信息列表
+			List<TypeBrief> types = farmDocTypeManagerImpl.getTypesForWriteDoc(getCurrentUser(session));
+			// 将文档信息和类型信息放入视图模型，并返回创建知识页面的视图模型
+			return ViewMode.getInstance().putAttr("doce", doc).putAttr("types", types)
+					.returnModelAndView(ThemesUtil.getThemePath() + "/know/creat");
+		} catch (Exception e) {
+			// 如果发生异常，设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+
+	/**
+	 * 进入修改知识页面
+	 *
+	 * @param docid    文档 ID
+	 * @param session  HTTP 会话对象
+	 * @return ModelAndView 对象，包含文档信息和类型信息以及视图信息
+	 */
+	// 映射 /edit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@SuppressWarnings("deprecation")
+	@RequestMapping("/edit")
+	public ModelAndView edit(String docid, HttpSession session) {
+		// 完整的文档信息对象
+		DocEntire doce = null;
+		try {
+			// 根据文档 ID 获取完整的文档信息
+			doce = farmDocManagerImpl.getDoc(docid);
+			// 解决 kindedit 中 HTML 脚本被转义的问题
+			doce.getTexts()
+					.setText1(doce.getTexts().getText1().replaceAll("&gt;", "&amp;gt;").replaceAll("&lt;", "&amp;lt;"));
+
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+		}
+		// 获取当前用户可用于撰写文档的类型简要信息列表
+		List<TypeBrief> types = farmDocTypeManagerImpl.getTypesForWriteDoc(getCurrentUser(session));
+		// 将文档信息和类型信息放入视图模型，并返回修改知识页面的视图模型
+		return ViewMode.getInstance().putAttr("doce", doce).putAttr("types", types)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/know/edit");
+	}
+
+	/**
+	 * 提交创建知识请求
+	 *
+	 * @param docgroup  文档小组 ID
+	 * @param knowtitle 知识标题
+	 * @param knowtype  知识类型
+	 * @param text      知识内容
+	 * @param knowtag   知识标签
+	 * @param writetype 写入权限类型
+	 * @param readtype  读取权限类型
+	 * @param session   HTTP 会话对象
+	 * @return ModelAndView 对象，根据创建结果进行重定向
+	 */
+	// 映射 /addsubmit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/addsubmit")
+	public ModelAndView submitAdd(String docgroup, String knowtitle, String knowtype, String text, String knowtag,
+								  String writetype, String readtype, HttpSession session) {
+		// 完整的文档信息对象
+		DocEntire doc = null;
+		try {
+			// 如果文档小组 ID 为 "0"，则将其设置为 null
+			if ("0".equals(docgroup)) {
+				docgroup = null;
+			}
+			// 调用服务层方法创建知识文档
+			doc = KnowServiceImpl.creatKnow(knowtitle, knowtype, text, knowtag, POP_TYPE.getEnum(writetype),
+					POP_TYPE.getEnum(readtype), docgroup, getCurrentUser(session));
+		} catch (Exception e) {
+			// 如果发生异常，设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+		// 如果文档有审核信息
+		if (doc.getAudit() != null) {
+			// 重定向到审核页面
+			return ViewMode.getInstance().returnRedirectUrl("/audit/tempdoc.do?auditid=" + doc.getAudit().getId());
+		}
+		// 重定向到文档查看页面
+		return ViewMode.getInstance().returnRedirectUrl("/webdoc/view/Pub" + doc.getDoc().getId() + ".html");
+	}
+
+	/**
+	 * 提交修改知识请求
+	 *
+	 * @param docid     文档 ID
+	 * @param docgroup  文档小组 ID
+	 * @param knowtitle 知识标题
+	 * @param knowtype  知识类型
+	 * @param text      知识内容
+	 * @param knowtag   知识标签
+	 * @param writetype 写入权限类型
+	 * @param readtype  读取权限类型
+	 * @param editNote  修改备注
+	 * @param session   HTTP 会话对象
+	 * @return ModelAndView 对象，根据修改结果进行重定向
+	 */
+	// 映射 /editsubmit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@SuppressWarnings("deprecation")
+	@RequestMapping("/editsubmit")
+	public ModelAndView editCommit(String docid, String docgroup, String knowtitle, String knowtype, String text,
+								   String knowtag, String writetype, String readtype, String editNote, HttpSession session) {
+		// 完整的文档信息对象
+		DocEntire doc = null;
+		try {
+			// 如果文档小组 ID 为 "0"，则将其设置为 null
+			if ("0".equals(docgroup)) {
+				docgroup = null;
+			}
+			// 如果当前用户有删除该文档的权限（高级权限用户）
+			if (farmDocOperateRightImpl.isDel(getCurrentUser(session), farmDocManagerImpl.getDocOnlyBean(docid))) {
+				// 调用服务层方法进行高级权限的知识修改
+				doc = KnowServiceImpl.editKnow(docid, knowtitle, knowtype, text, knowtag, POP_TYPE.getEnum(writetype),
+						POP_TYPE.getEnum(readtype), docgroup, getCurrentUser(session), editNote);
+				// 重定向到文档查看页面
+				return ViewMode.getInstance().returnRedirectUrl("/webdoc/view/Pub" + docid + ".html");
+			}
+			// 低级权限用户修改
+			{
+				// 调用服务层方法进行低级权限的知识修改
+				doc = KnowServiceImpl.editKnow(docid, text, knowtag, getCurrentUser(session), editNote);
+			}
+		} catch (Exception e) {
+			// 获取当前用户可用于撰写文档的类型简要信息列表
+			List<TypeBrief> types = farmDocTypeManagerImpl.getTypesForWriteDoc(getCurrentUser(session));
+			// 将文档信息和类型信息放入视图模型，并返回修改知识页面的视图模型
+			return ViewMode.getInstance().putAttr("doce", farmDocManagerImpl.getDoc(doc.getDoc().getId()))
+					.putAttr("types", types).returnModelAndView(ThemesUtil.getThemePath() + "/know/edit");
+		}
+		// 如果文档有审核信息
+		if (doc.getAudit() != null) {
+			// 重定向到审核页面
+			return ViewMode.getInstance().returnRedirectUrl("/audit/tempdoc.do?auditid=" + doc.getAudit().getId());
+		}
+		// 重定向到文档查看页面
+		return ViewMode.getInstance().returnRedirectUrl("/webdoc/view/Pub" + doc.getDoc().getId() + ".html");
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/LoginController.java

@@ -0,0 +1,231 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Logger 类，用于日志记录
+import org.apache.log4j.Logger;
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 FarmAuthorityService 类，用于权限相关操作
+import com.farm.authority.FarmAuthorityService;
+// 导入 LoginUserNoExistException 异常类，用于处理用户不存在的情况
+import com.farm.core.auth.exception.LoginUserNoExistException;
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DefaultIndexPageTaget 类，用于获取默认首页相关信息
+import com.farm.doc.tag.DefaultIndexPageTaget;
+// 导入 FarmParameterService 类，用于获取参数相关操作
+import com.farm.parameter.FarmParameterService;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+// 导入 OnlineUserOpImpl 类，用于处理在线用户操作的实现类
+import com.farm.web.online.OnlineUserOpImpl;
+// 导入 OnlineUserOpInter 接口，用于处理在线用户操作
+import com.farm.web.online.OnlineUserOpInter;
+
+// 定义请求映射的根路径为 /login
+@RequestMapping("/login")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class LoginController extends WebUtils {
+	// 创建 Logger 实例，用于记录该类的日志信息
+	private final static Logger log = Logger.getLogger(LoginController.class);
+
+	/**
+	 * 处理登录提交请求
+	 *
+	 * @param name     用户名
+	 * @param password 密码
+	 * @param request  HTTP 请求对象
+	 * @param session  HTTP 会话对象
+	 * @return ModelAndView 对象，根据登录结果进行重定向或返回登录页面
+	 */
+	// 映射 /submit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/submit")
+	public ModelAndView loginCommit(String name, String password, HttpServletRequest request, HttpSession session) {
+		try {
+			// 检查用户名和密码是否合法
+			if (FarmAuthorityService.getInstance().isLegality(name, password)) {
+				// 登录成功
+				// 将用户信息注册到 session 中
+				loginIntoSession(session, getCurrentIp(request), name);
+				// 重定向到系统框架首页
+				return ViewMode.getInstance().returnRedirectUrl("/frame/index.do");
+			} else {
+				// 登录失败
+				// 将错误信息放入视图模型，并返回登录页面
+				return ViewMode.getInstance().putAttr("message", "用户密码错误").returnModelAndView("frame/login");
+			}
+		} catch (LoginUserNoExistException e) {
+			// 记录当前用户不存在的日志信息
+			log.info("当前用户不存在");
+			// 将错误信息放入视图模型，并返回登录页面
+			return ViewMode.getInstance().putAttr("message", "当前用户不存在").returnModelAndView("frame/login");
+		}
+	}
+
+	/**
+	 * 进入登录页面
+	 *
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return ModelAndView 对象，返回登录页面的视图模型
+	 */
+	// 映射 /webPage 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/webPage")
+	public ModelAndView login(HttpSession session, HttpServletRequest request) {
+		// 获取登录前的页面地址
+		String url = request.getHeader("Referer");
+		// 将登录前的页面地址存入 session 中
+		session.setAttribute(FarmParameterService.getInstance().getParameter("farm.constant.session.key.from.url"),
+				url);
+		// 返回登录页面的视图模型
+		return ViewMode.getInstance().returnModelAndView(ThemesUtil.getThemePath() + "/login");
+	}
+
+	/**
+	 * 处理网页登录提交请求
+	 *
+	 * @param name     用户名
+	 * @param password 密码
+	 * @param request  HTTP 请求对象
+	 * @param session  HTTP 会话对象
+	 * @return ModelAndView 对象，根据登录结果进行重定向或返回登录页面
+	 */
+	// 映射 /websubmit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/websubmit")
+	public ModelAndView webLoginCommit(String name, String password, HttpServletRequest request, HttpSession session) {
+		try {
+			// 检查用户名和密码是否合法
+			if (FarmAuthorityService.getInstance().isLegality(name, password)) {
+				// 登录成功
+				// 将用户信息注册到 session 中
+				loginIntoSession(session, getCurrentIp(request), name);
+				// 要跳转的目标 URL
+				String goUrl = null;
+				if (goUrl == null) {
+					// 从 session 中获取要去的目标 URL
+					goUrl = (String) session.getAttribute(
+							FarmParameterService.getInstance().getParameter("farm.constant.session.key.go.url"));
+					// 从 session 中移除该目标 URL
+					session.removeAttribute(
+							FarmParameterService.getInstance().getParameter("farm.constant.session.key.go.url"));
+				}
+				if (goUrl == null) {
+					// 从 session 中获取登录前的页面地址
+					goUrl = (String) session.getAttribute(
+							FarmParameterService.getInstance().getParameter("farm.constant.session.key.from.url"));
+				}
+				if (goUrl != null && goUrl.indexOf("login/webPage") > 0) {
+					// 如果返回的是登录页面，则设置目标 URL 为 null，即去默认首页
+					goUrl = null;
+				}
+				if (goUrl == null) {
+					// 设置默认页面为目标 URL
+					goUrl = "/" + DefaultIndexPageTaget.getDefaultIndexPage();
+				}
+				// 重定向到目标 URL
+				return ViewMode.getInstance().returnRedirectUrl(goUrl);
+			} else {
+				// 登录失败
+				// 将用户名和错误信息放入视图模型，并返回登录页面
+				return ViewMode.getInstance().putAttr("loginname", name).setError("用户密码错误")
+						.returnModelAndView(ThemesUtil.getThemePath() + "/login");
+			}
+		} catch (LoginUserNoExistException e) {
+			// 记录当前用户不存在的日志信息
+			log.info("当前用户不存在");
+			// 将用户名和错误信息放入视图模型，并返回登录页面
+			return ViewMode.getInstance().putAttr("loginname", name).setError("当前用户不存在")
+					.returnModelAndView(ThemesUtil.getThemePath() + "/login");
+		}
+	}
+
+	/**
+	 * 处理用户登出请求（网页登出）
+	 *
+	 * @param name    用户名（未使用）
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，重定向到默认首页
+	 */
+	// 映射 /webout 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/webout")
+	public ModelAndView weblogOut(String name, HttpSession session) {
+		// 清除当前用户的 session 信息
+		clearCurrentUser(session);
+		// 重定向到默认首页
+		return ViewMode.getInstance().returnRedirectUrl("/" + DefaultIndexPageTaget.getDefaultIndexPage());
+	}
+
+	/**
+	 * 进入登录页面（重载方法，仅接收用户名参数）
+	 *
+	 * @param name 用户名（未使用）
+	 * @return ModelAndView 对象，返回登录页面的视图模型
+	 */
+	// 映射 /page 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/page")
+	public ModelAndView login(String name) {
+		// 返回登录页面的视图模型
+		return ViewMode.getInstance().returnModelAndView("frame/login");
+	}
+
+	/**
+	 * 处理用户登出请求
+	 *
+	 * @param name    用户名（未使用）
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，重定向到登录页面
+	 */
+	// 映射 /out 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/out")
+	public ModelAndView logOut(String name, HttpSession session) {
+		// 清除当前用户的 session 信息
+		clearCurrentUser(session);
+		// 重定向到登录页面
+		return ViewMode.getInstance().returnRedirectUrl("/login/page.do");
+	}
+
+	/**
+	 * 将登录信息写入 session
+	 *
+	 * @param session   HTTP 会话对象
+	 * @param ip        用户的 IP 地址
+	 * @param loginName 登录用户名
+	 */
+	private void loginIntoSession(HttpSession session, String ip, String loginName) {
+		// 开始写入 session 用户信息
+		// 根据登录用户名获取用户信息并设置到 session 中
+		setCurrentUser(FarmAuthorityService.getInstance().getUserByLoginName(loginName), session);
+		// 设置用户登录时间到 session 中
+		setLoginTime(session);
+		// 开始写入 session 用户权限
+		// 根据当前用户 ID 获取用户权限键并设置到 session 中
+		setCurrentUserAction(FarmAuthorityService.getInstance().getUserAuthKeys(getCurrentUser(session).getId()),
+				session);
+		// 开始写入 session 用户菜单
+		// 根据当前用户 ID 获取用户菜单并设置到 session 中
+		setCurrentUserMenu(FarmAuthorityService.getInstance().getUserMenu(getCurrentUser(session).getId()), session);
+		// 写入用户上线信息
+		// 创建在线用户操作对象
+		OnlineUserOpInter ouop = null;
+		ouop = OnlineUserOpImpl.getInstance(ip, loginName, session);
+		// 处理用户登录操作
+		ouop.userLoginHandle(FarmAuthorityService.getInstance().getUserByLoginName(loginName));
+		// 记录用户登录时间（调用权限服务的方法）
+		FarmAuthorityService.getInstance().loginHandle(getCurrentUser(session).getId());
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/UserController.java

@@ -0,0 +1,464 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 SQLException 异常类，用于处理 SQL 相关异常
+import java.sql.SQLException;
+// 导入 Map 接口，用于存储键值对
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ResponseBody 注解，用于将返回值直接作为响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 Organization 类，用于表示组织机构实体
+import com.farm.authority.domain.Organization;
+// 导入 User 类，用于表示用户实体
+import com.farm.authority.domain.User;
+// 导入 UserServiceInter 接口，用于用户服务相关操作
+import com.farm.authority.service.UserServiceInter;
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DataResult 类，用于封装数据查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入 FarmDocManagerInter 接口，用于文档管理相关操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，用于文档操作权限相关操作
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 FarmDocRunInfoInter 接口，用于文档运行信息相关操作
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocgroupManagerInter 接口，用于文档小组管理相关操作
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理相关操作
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileManagerInter 接口，用于文件管理相关操作
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 UsermessageServiceInter 接口，用于用户消息服务相关操作
+import com.farm.doc.server.UsermessageServiceInter;
+// 导入 DocumentConfig 类，用于文档配置相关操作
+import com.farm.doc.server.commons.DocumentConfig;
+// 导入 FarmParameterService 类，用于获取参数相关操作
+import com.farm.parameter.FarmParameterService;
+// 导入 KnowServiceInter 接口，用于知识服务相关操作
+import com.farm.wcp.know.service.KnowServiceInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 用户相关操作的控制器类，处理用户信息修改、注册、首页展示等功能
+ *
+ * @author autoCode
+ */
+// 定义请求映射的根路径为 /webuser
+@RequestMapping("/webuser")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class UserController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档小组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 KnowServiceInter 接口的实现类实例，用于知识服务
+	@Resource
+	private KnowServiceInter knowServiceImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 UserServiceInter 接口的实现类实例，用于用户服务
+	@Resource
+	private UserServiceInter userServiceImpl;
+	// 注入 UsermessageServiceInter 接口的实现类实例，用于用户消息服务
+	@Resource
+	private UsermessageServiceInter usermessageServiceImpl;
+
+	// 原本的日志记录器定义被注释掉了
+	// private final static Logger log = Logger.getLogger(UserController.class);
+
+	/**
+	 * 进入修改用户信息页面
+	 *
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，包含用户信息、头像信息、机构信息等，并返回修改用户信息页面的视图模型
+	 */
+	// 映射 /edit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/edit")
+	public ModelAndView editUser(HttpSession session) {
+		try {
+			// 根据当前用户的 ID 获取用户实体
+			User user = userServiceImpl.getUserEntity(getCurrentUser(session).getId());
+			// 获取用户名称
+			String name = user.getName();
+			// 获取用户头像 ID
+			String photoid = user.getImgid();
+			// 初始化头像 URL 为 null
+			String photourl = null;
+			// 如果头像 ID 不为空
+			if (photoid != null && photoid.trim().length() > 0) {
+				// 根据头像 ID 获取头像 URL
+				photourl = farmFileManagerImpl.getFileURL(photoid);
+			}
+
+			// 根据用户 ID 获取用户所在的组织机构
+			Organization org = userServiceImpl.getOrg(user.getId());
+			// 从配置参数中获取是否显示机构的配置信息
+			String showOrgStr = FarmParameterService.getInstance().getParameter("config.regist.showOrg");
+			// 初始化是否显示机构的标志为 false
+			boolean showOrg = false;
+			// 如果配置信息为 "true"
+			if ("true".equals(showOrgStr)) {
+				// 设置显示机构的标志为 true
+				showOrg = true;
+			}
+
+			// 将用户信息、名称、头像 ID、机构信息、是否显示机构标志、头像 URL 放入视图模型，并返回修改用户信息页面的视图模型
+			return ViewMode.getInstance().putAttr("user", user).putAttr("name", name).putAttr("photoid", photoid)
+					.putAttr("org", org).putAttr("showOrg", showOrg).putAttr("photourl", photourl)
+					.returnModelAndView(ThemesUtil.getThemePath() + "/user/userInfoEdit");
+		} catch (Exception e) {
+			// 如果发生异常，设置错误信息并返回修改用户信息页面的视图模型
+			return ViewMode.getInstance().setError(e.toString()).returnModelAndView(ThemesUtil.getThemePath() + "/user/userInfoEdit");
+		}
+	}
+
+	/**
+	 * 进入用户注册页面
+	 *
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，包含默认头像 URL 和是否显示机构标志，并返回用户注册页面的视图模型
+	 */
+	// 映射 /PubRegist 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubRegist")
+	public ModelAndView regist(HttpSession session) {
+		// 从配置参数中获取是否显示机构的配置信息
+		String showOrgStr = FarmParameterService.getInstance().getParameter("config.regist.showOrg");
+		// 初始化是否显示机构的标志为 false
+		boolean showOrg = false;
+		// 如果配置信息为 "true"
+		if ("true".equals(showOrgStr)) {
+			// 设置显示机构的标志为 true
+			showOrg = true;
+		}
+		// 将默认头像 URL 和是否显示机构标志放入视图模型，并返回用户注册页面的视图模型
+		return ViewMode.getInstance()
+				.putAttr("imgUrl", DocumentConfig.getString("config.doc.download.url") + "402888ac501d764801501d817b9e0011")
+				.putAttr("showOrg", showOrg).returnModelAndView(ThemesUtil.getThemePath() + "/user/regist");
+	}
+
+	/**
+	 * 处理用户注册提交请求
+	 *
+	 * @param photoid    用户头像 ID
+	 * @param loginname  用户登录名
+	 * @param name       用户名称
+	 * @param password   用户密码
+	 * @param orgid      用户所在机构 ID
+	 * @param session    HTTP 会话对象
+	 * @return ModelAndView 对象，根据注册结果进行重定向或返回注册页面
+	 */
+	// 映射 /PubRegistCommit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubRegistCommit")
+	public ModelAndView registSubmit(String photoid, String loginname, String name, String password, String orgid,
+									 HttpSession session) {
+		// 创建一个新的用户对象
+		User user = new User();
+		try {
+			// 从配置参数中获取系统是否允许注册的配置信息
+			if (FarmParameterService.getInstance().getParameter("config.sys.registable ").equals("false")) {
+				// 如果不允许注册，抛出运行时异常
+				throw new RuntimeException("该操作已经被管理员禁用!");
+			}
+			// 设置用户头像 ID
+			user.setImgid(photoid);
+			// 设置用户登录名
+			user.setLoginname(loginname);
+			// 设置用户名称
+			user.setName(name);
+			// 设置用户状态为 "1"
+			user.setState("1");
+			// 设置用户类型为 "1"
+			user.setType("1");
+			// 调用用户服务的注册方法进行用户注册
+			user = userServiceImpl.registUser(user, orgid);
+			// 调用用户服务的修改登录密码方法，将默认密码修改为用户输入的密码
+			userServiceImpl.editLoginPassword(loginname,
+					FarmParameterService.getInstance().getParameter("config.default.password"), password);
+
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 如果头像 ID 为空
+			if (photoid == null || photoid.isEmpty()) {
+				// 设置默认头像 ID
+				photoid = "402888ac501d764801501d817b9e0011";
+			}
+			// 将头像 ID、登录名、名称、机构 ID、头像 URL、错误信息放入视图模型，并返回用户注册页面的视图模型
+			return ViewMode.getInstance()
+					.putAttr("photoid", photoid)
+					.putAttr("loginname", loginname)
+					.putAttr("name", name)
+					.putAttr("orgid", orgid)
+					.putAttr("imgUrl", DocumentConfig.getString("config.doc.download.url") + photoid)
+					.putAttr("errorMessage", e.getMessage())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/user/regist");
+		}
+		// 将登录名和密码放入视图模型，并重定向到登录提交页面
+		return ViewMode.getInstance()
+				.putAttr("name", loginname)
+				.putAttr("password", password)
+				.returnRedirectUrl("/login/websubmit.do");
+	}
+
+	/**
+	 * 展示用户首页
+	 *
+	 * @param userid  用户 ID
+	 * @param type    展示类型，如 "know"、"file" 等
+	 * @param num     当前页码
+	 * @param session HTTP 会话对象
+	 * @return ModelAndView 对象，包含用户信息、文档信息等，并返回用户首页的视图模型
+	 */
+	// 映射 /PubHome 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/PubHome")
+	public ModelAndView showUserHome(String userid, String type, Integer num, HttpSession session) {
+		// 创建视图模式实例
+		ViewMode mode = ViewMode.getInstance();
+		// 初始化是否是当前用户自己的标志为 false
+		boolean isSelf = false;
+		// 初始化数据查询结果对象为 null
+		DataResult result = null;
+		// 初始化用户对象为 null
+		User user = null;
+		try {
+			// 如果用户 ID 为空
+			if (userid == null) {
+				// 根据当前用户的 ID 获取用户实体
+				user = userServiceImpl.getUserEntity(getCurrentUser(session).getId());
+				// 将是否是当前用户自己的标志放入视图模型
+				mode.putAttr("self", true);
+				// 设置是否是当前用户自己的标志为 true
+				isSelf = true;
+			} else {
+				// 根据传入的用户 ID 获取用户实体
+				user = userServiceImpl.getUserEntity(userid);
+				// 判断当前用户是否和传入的用户是同一用户
+				if (user.getId().equals(getCurrentUser(session) != null ? getCurrentUser(session).getId() : "none")) {
+					// 如果是同一用户，将是否是当前用户自己的标志放入视图模型
+					mode.putAttr("self", true);
+					// 设置是否是当前用户自己的标志为 true
+					isSelf = true;
+				} else {
+					// 如果不是同一用户，将是否是当前用户自己的标志放入视图模型
+					mode.putAttr("self", false);
+					// 设置是否是当前用户自己的标志为 false
+					isSelf = false;
+				}
+			}
+			// 如果用户不为空
+			if (user != null) {
+				// 根据用户信息获取用户统计数据
+				DataResult users = farmDocRunInfoImpl.getStatUser(user);
+				// 如果用户有头像 ID
+				if (user.getImgid() != null && user.getImgid().trim().length() > 0) {
+					// 根据头像 ID 获取头像 URL 并放入视图模型
+					mode.putAttr("photourl", farmFileManagerImpl.getFileURL(user.getImgid()));
+				}
+				// 将用户统计数据放入视图模型
+				mode.putAttr("users", users);
+			}
+			// --------------------------查询知识列表和小组------------------------------
+			// 如果当前页码为空
+			if (num == null) {
+				// 设置当前页码为 1
+				num = 1;
+			}
+			// 如果展示类型为空
+			if (type == null) {
+				// 设置展示类型为 "know"
+				type = "know";
+			}
+			// 根据展示类型进行不同的查询操作
+			if (type.equals("know")) {
+				// 发布知识
+				// 如果是当前用户自己，查询用户发布的所有文档；否则查询用户公开的文档
+				result = isSelf ? farmDocRunInfoImpl.userDocs(user.getId(), "1", 10, num)
+						: farmDocRunInfoImpl.userPubDocs(user.getId(), "1", 10, num);
+			}
+			if (type.equals("file")) {
+				// 发布资源
+				// 如果是当前用户自己，查询用户发布的资源文档；否则查询用户公开的资源文档
+				result = isSelf ? farmDocRunInfoImpl.userDocs(user.getId(), "5", 10, num)
+						: farmDocRunInfoImpl.userPubDocs(user.getId(), "5", 10, num);
+			}
+			if (type.equals("joy")) {
+				// 如果用户 ID 不为空
+				if (userid != null && !userid.isEmpty()) {
+					// 我的关注
+					// 查询用户关注的文档，并设置当前页码和每页数量，然后执行查询
+					result = farmDocRunInfoImpl.getUserEnjoyDoc(user.getId()).setCurrentPage(num).setPagesize(10)
+							.search();
+					// 格式化文档发布时间
+					result.runformatTime("PUBTIME", "yyyy-MM-dd HH:mm");
+				}
+			}
+			if (type.equals("group")) {
+				// 加入小组
+				// 根据用户 ID 查询用户加入的小组，并设置每页数量和当前页码
+				result = farmDocgroupManagerImpl.getGroupsByUser(user.getId(), 16, num);
+			}
+			if (type.equals("audit")) {
+				// 审核中
+				// 查询用户正在审核中的文档，并设置每页数量和当前页码
+				result = farmDocRunInfoImpl.getMyAuditingByUser(user.getId(), 10, num);
+				// 格式化文档发布时间
+				result.runformatTime("PUBTIME", "yyyy-MM-dd HH:mm");
+				// 对文档状态进行字典转换
+				result.runDictionary("1:待审核,2:审核通过,3:审核未通过,4:废弃", "STATE");
+			}
+			if (type.equals("audito")) {
+				// 审核任务
+				// 查询用户的审核任务文档，并设置每页数量和当前页码
+				result = farmDocRunInfoImpl.getAuditDocByUser(user.getId(), 10, num);
+				// 格式化文档发布时间
+				result.runformatTime("PUBTIME", "yyyy-MM-dd HH:mm");
+				// 对文档状态进行字典转换
+				result.runDictionary("1:待审核,2:审核通过,3:审核未通过,4:废弃", "STATE");
+			}
+			if (type.equals("audith")) {
+				// 审核历史
+				// 查询用户的审核历史文档，并设置每页数量和当前页码
+				result = farmDocRunInfoImpl.getMyAuditedByUser(user.getId(), 10, num);
+				// 格式化文档发布时间
+				result.runformatTime("PUBTIME", "yyyy-MM-dd HH:mm");
+				// 对文档状态进行字典转换
+				result.runDictionary("1:待审核,2:审核通过,3:审核未通过,4:废弃", "STATE");
+			}
+			if (type.equals("usermessage")) {
+				// 用户消息
+				// 根据当前用户的 ID 查询用户消息，并设置每页数量和当前页码
+				result = usermessageServiceImpl.getMyMessageByUser(getCurrentUser(session).getId(), 10, num);
+				// 格式化用户消息创建时间
+				result.runformatTime("USERMESSAGECTIME", "yyyy-MM-dd HH:mm");
+				// 对消息阅读状态进行字典转换
+				result.runDictionary("0:未读,1:已读", "READSTATE");
+			}
+		} catch (SQLException e) {
+			// 如果发生 SQL 异常，设置错误信息并返回错误页面的视图模型
+			return mode.setError(e.toString()).returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+		// 将文档查询结果、用户 ID、展示类型、当前页码放入视图模型，并返回用户首页的视图模型
+		return mode.putAttr("docs", result)
+				.putAttr("userid", user.getId())
+				.putAttr("type", type)
+				.putAttr("num", num)
+				.returnModelAndView(ThemesUtil.getThemePath() + "/user/userHome");
+	}
+
+	/**
+	 * 更新当前登录用户的信息
+	 *
+	 * @param name     用户名称
+	 * @param photoid  用户头像 ID
+	 * @param orgid    用户所在机构 ID
+	 * @param session  HTTP 会话对象
+	 * @return ModelAndView 对象，根据更新结果进行重定向或返回错误页面
+	 */
+	// 映射 /editCurrentUser 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/editCurrentUser")
+	public ModelAndView editCurrentUser(String name, String photoid, String orgid, HttpSession session) {
+		try {
+			// 调用用户服务的修改当前用户信息方法
+			userServiceImpl.editCurrentUser(getCurrentUser(session).getId(), name, photoid, orgid);
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 如果发生异常，设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString()).returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+		// 重定向到用户首页
+		return ViewMode.getInstance().returnRedirectUrl("/webuser/PubHome.do");
+	}
+
+	/**
+	 * 跳转到修改密码页面
+	 *
+	 * @return ModelAndView 对象，返回修改密码页面的视图模型
+	 */
+	// 映射 /editCurrentUserPwd 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/editCurrentUserPwd")
+	public ModelAndView editCurrentUserPwd() {
+		// 返回修改密码页面的视图模型
+		return ViewMode.getInstance().returnModelAndView(ThemesUtil.getThemePath() + "/user/passwordEdit");
+	}
+
+	/**
+	 * 更新当前登录用户的密码
+	 *
+	 * @param password     当前密码
+	 * @param newPassword  新密码
+	 * @param session      HTTP 会话对象
+	 * @return ModelAndView 对象，根据更新结果进行重定向或返回错误页面
+	 */
+	// 映射 /editCurrentUserPwdCommit 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/editCurrentUserPwdCommit")
+	public ModelAndView editCurrentUserPwdCommit(String password, String newPassword, HttpSession session) {
+		try {
+			// 调用用户服务的修改当前用户密码方法
+			userServiceImpl.editCurrentUserPwdCommit(getCurrentUser(session).getId(), password, newPassword);
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 如果发生异常，设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString()).returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+		// 重定向到用户首页
+		return ViewMode.getInstance().returnRedirectUrl("/webuser/PubHome.do");
+	}
+
+	/**
+	 * 验证当前用户密码的有效性
+	 *
+	 * @param password  用户输入的密码
+	 * @param session   HTTP 会话对象
+	 * @return Map<String, Object> 包含验证结果的键值对
+	 */
+	// 映射 /validCurrUserPwd 请求路径，处理默认请求（未指定方法，通常为 GET），并将返回值直接作为响应体
+	@RequestMapping("/validCurrUserPwd")
+	@ResponseBody
+	public Map<String, Object> validCurrUserPwd(String password, HttpSession session) {
+		try {
+			// 调用用户服务的验证当前用户密码方法
+			boolean b = userServiceImpl.validCurrentUserPwd(getCurrentUser(session).getId(), password);
+			// 将验证结果放入视图模型并返回
+			return ViewMode.getInstance().putAttr("validCurrentUserPwd", b).returnObjMode();
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 如果发生异常，设置错误信息并返回包含错误信息的视图模型
+			return ViewMode.getInstance().setError(e.toString()).returnObjMode();
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/UserMessageController.java

@@ -0,0 +1,137 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 List 接口，用于处理有序集合
+import java.util.List;
+// 导入 Map 接口，用于处理键值对集合
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 的控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ResponseBody 注解，用于将方法的返回值直接写入响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 ViewMode 类，用于处理视图模式相关操作
+import com.farm.core.page.ViewMode;
+// 导入 DBRule 类，用于数据库查询规则
+import com.farm.core.sql.query.DBRule;
+// 导入 DBSort 类，用于数据库查询排序
+import com.farm.core.sql.query.DBSort;
+// 导入 DataQuery 类，用于数据库查询操作
+import com.farm.core.sql.query.DataQuery;
+// 导入 Usermessage 类，用于表示用户消息实体
+import com.farm.doc.domain.Usermessage;
+// 导入 UsermessageServiceInter 接口，用于用户消息服务相关操作
+import com.farm.doc.server.UsermessageServiceInter;
+// 导入 FarmDocmessageManagerInter 接口，用于文档消息管理相关操作
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WebUtils 类，可能包含一些通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 用户消息相关的控制器类
+ *
+ * @author autoCode
+ */
+// 定义请求映射的根路径为 /webusermessage
+@RequestMapping("/webusermessage")
+// 将该类标记为 Spring MVC 的控制器
+@Controller
+// 继承 WebUtils 类，以获取其中的工具方法
+public class UserMessageController extends WebUtils {
+	// 注入 UsermessageServiceInter 接口的实现类实例，用于用户消息服务
+	@Resource
+	private UsermessageServiceInter usermessageServiceImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+
+	/**
+	 * 查看用户消息详情
+	 *
+	 * @param id  消息 ID
+	 * @param num 分页参数（返回消息列表需要）
+	 * @return ModelAndView 对象，包含用户消息信息、消息阅读状态名称和分页参数，以及对应的视图
+	 */
+	// 映射 /showMessage 请求路径，处理默认请求（未指定方法，通常为 GET）
+	@RequestMapping("/showMessage")
+	public ModelAndView showMessage(String id, Integer num) {
+		try {
+			// 将指定 ID 的用户消息标记为已读
+			usermessageServiceImpl.setRead(id);
+			// 根据消息 ID 获取用户消息实体
+			Usermessage usermessage = usermessageServiceImpl.getUsermessageEntity(id);
+			// 消息阅读状态名称
+			String readstatename = "";
+			// 判断消息的阅读状态
+			if (usermessage.getReadstate().equals("0")) { // 0 表示未读、1 表示已读
+				readstatename = "未读";
+			} else if (usermessage.getReadstate().equals("1")) {
+				readstatename = "已读";
+			}
+			// 将用户消息实体、消息阅读状态名称、分页参数放入视图模型，并返回用户消息详情页面的视图模型
+			return ViewMode.getInstance()
+					.putAttr("usermessage", usermessage)
+					.putAttr("readstatename", readstatename)
+					.putAttr("num", num)
+					.returnModelAndView(ThemesUtil.getThemePath() + "/know/userMessage");
+		} catch (Exception e) {
+			// 如果发生异常，设置错误信息并返回空的视图模型
+			return ViewMode.getInstance().setError(e.toString()).returnModelAndView("");
+		}
+	}
+
+	/**
+	 * 显示首页未读消息
+	 *
+	 * @param session HTTP 会话对象
+	 * @return Map<String, Object> 包含新消息标题和未读消息数量的键值对
+	 */
+	// 映射 /showHomeMessage 请求路径，处理默认请求（未指定方法，通常为 GET），并将返回值作为响应体返回
+	@RequestMapping("/showHomeMessage")
+	@ResponseBody
+	public Map<String, Object> showHomeMessage(HttpSession session) {
+		try {
+			// 创建一个用户消息的简单查询对象
+			DataQuery query = usermessageServiceImpl.createUsermessageSimpleQuery(null);
+			// 设置不进行计数查询（可能是为了只获取数据而不统计总数）
+			query.setNoCount();
+			// 添加查询规则，筛选出当前用户为接收者的消息
+			query.addRule(new DBRule("USERMESSAGE.READUSERID", getCurrentUser(session).getId(), "="));
+			// 添加查询规则，筛选出未读的消息
+			query.addRule(new DBRule("USERMESSAGE.READSTATE", "0", "="));
+			// 添加排序规则，按消息创建时间降序排列
+			query.addSort(new DBSort("USERMESSAGE.CTIME", "DESC"));
+			// 执行查询并获取结果列表
+			List<Map<String, Object>> list = query.search().getResultList();
+			// 新消息标题
+			String newMessage = "";
+			// 如果结果列表不为空且有数据
+			if (list != null && list.size() > 0) {
+				// 获取第一条消息的标题
+				newMessage = list.get(0).get("TITLE").toString();
+			}
+
+			// 将新消息标题和未读消息数量放入视图模型，并返回对应的键值对
+			return ViewMode.getInstance()
+					.putAttr("newMessage", newMessage)
+					.putAttr("unReadCount", list.size())
+					.returnObjMode();
+		} catch (Exception e) {
+			// 如果发生异常，返回空的视图模型对应的键值对
+			return ViewMode.getInstance().returnObjMode();
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/controller/WebFileController.java

@@ -0,0 +1,333 @@
+// 声明包路径
+package com.farm.wcp.controller;
+
+// 导入 ArrayList 类，用于创建动态数组
+import java.util.ArrayList;
+// 导入 Arrays 类，提供了操作数组的静态方法
+import java.util.Arrays;
+// 导入 HashMap 类，用于存储键值对
+import java.util.HashMap;
+// 导入 List 接口，用于表示有序集合
+import java.util.List;
+// 导入 Map 接口，用于表示键值对映射
+import java.util.Map;
+
+// 导入 Resource 注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Controller 注解，将该类标记为 Spring MVC 控制器
+import org.springframework.stereotype.Controller;
+// 导入 RequestMapping 注解，用于映射请求路径
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入 UserServiceInter 接口，提供用户服务相关功能
+import com.farm.authority.service.UserServiceInter;
+// 导入 ViewMode 类，用于构建视图模型
+import com.farm.core.page.ViewMode;
+// 导入 Doc 类，代表文档实体
+import com.farm.doc.domain.Doc;
+// 导入 FarmDoctype 类，代表文档类型实体
+import com.farm.doc.domain.FarmDoctype;
+// 导入 DocEntire 类，代表完整的文档实体
+import com.farm.doc.domain.ex.DocEntire;
+// 导入 TypeBrief 类，代表文档类型的简要信息
+import com.farm.doc.domain.ex.TypeBrief;
+// 导入 FarmDocManagerInter 接口，提供文档管理相关功能
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 FarmDocOperateRightInter 接口，提供文档操作权限相关功能
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入 POP_TYPE 枚举，定义文档操作权限类型
+import com.farm.doc.server.FarmDocOperateRightInter.POP_TYPE;
+// 导入 FarmParameterService 类，用于获取系统参数
+import com.farm.parameter.FarmParameterService;
+// 导入 FarmDocRunInfoInter 接口，提供文档运行信息相关功能
+import com.farm.doc.server.FarmDocRunInfoInter;
+// 导入 FarmDocTypeInter 接口，提供文档类型管理相关功能
+import com.farm.doc.server.FarmDocTypeInter;
+// 导入 FarmDocgroupManagerInter 接口，提供文档组管理相关功能
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 FarmDocmessageManagerInter 接口，提供文档消息管理相关功能
+import com.farm.doc.server.FarmDocmessageManagerInter;
+// 导入 FarmFileManagerInter 接口，提供文件管理相关功能
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 ThemesUtil 类，用于处理主题相关的工具方法
+import com.farm.wcp.util.ThemesUtil;
+// 导入 WcpWebFileManagerInter 接口，提供 WCP 网页文件管理相关功能
+import com.farm.wcp.webfile.server.WcpWebFileManagerInter;
+// 导入 WebUtils 类，提供通用的 Web 工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 该控制器类主要处理资源文件相关的操作，如创建、编辑等
+ *
+ * @author autoCode
+ */
+// 定义请求映射的根路径为 /webfile
+@RequestMapping("/webfile")
+// 将该类标记为 Spring MVC 控制器
+@Controller
+// 继承 WebUtils 类，获取通用的 Web 工具方法
+public class WebFileController extends WebUtils {
+	// 注入 FarmDocgroupManagerInter 接口的实现类实例，用于文档组管理
+	@Resource
+	private FarmDocgroupManagerInter farmDocgroupManagerImpl;
+	// 注入 FarmFileManagerInter 接口的实现类实例，用于文件管理
+	@Resource
+	private FarmFileManagerInter farmFileManagerImpl;
+	// 注入 FarmDocManagerInter 接口的实现类实例，用于文档管理
+	@Resource
+	private FarmDocManagerInter farmDocManagerImpl;
+	// 注入 FarmDocRunInfoInter 接口的实现类实例，用于文档运行信息管理
+	@Resource
+	private FarmDocRunInfoInter farmDocRunInfoImpl;
+	// 注入 FarmDocmessageManagerInter 接口的实现类实例，用于文档消息管理
+	@Resource
+	private FarmDocmessageManagerInter farmDocmessageManagerImpl;
+	// 注入 FarmDocOperateRightInter 接口的实现类实例，用于文档操作权限管理
+	@Resource
+	private FarmDocOperateRightInter farmDocOperateRightImpl;
+	// 注入 UserServiceInter 接口的实现类实例，用于用户服务
+	@Resource
+	private UserServiceInter userServiceImpl;
+	// 注入 WcpWebFileManagerInter 接口的实现类实例，用于 WCP 网页文件管理
+	@Resource
+	private WcpWebFileManagerInter wcpWebFileManagerImpl;
+	// 注入 FarmDocTypeInter 接口的实现类实例，用于文档类型管理
+	@Resource
+	private FarmDocTypeInter farmDocTypeManagerImpl;
+
+	/**
+	 * 进入创建资源文件页面
+	 *
+	 * @param typeid  文档类型 ID
+	 * @param groupid 文档组 ID
+	 * @param session HTTP 会话对象
+	 * @return 包含相关数据的视图模型
+	 */
+	// 映射 /add 请求路径，处理默认请求（通常为 GET）
+	@RequestMapping("/add")
+	public ModelAndView creatWebFile(String typeid, String groupid, HttpSession session) {
+		// 创建一个新的完整文档实体，初始化为空文档
+		DocEntire doc = new DocEntire(new Doc());
+		// 如果传入的文档类型 ID 不为空且不是 "NONE"
+		if (typeid != null && !typeid.toUpperCase().trim().equals("NONE") && !typeid.toUpperCase().trim().equals("")) {
+			// 根据文档类型 ID 获取文档类型实体
+			FarmDoctype doctype = farmDocTypeManagerImpl.getType(typeid);
+			// 设置文档的类型
+			doc.setType(doctype);
+		}
+		// 如果传入的文档组 ID 不为空且不是 "NONE"
+		if (groupid != null && !groupid.toUpperCase().trim().equals("NONE")
+				&& !groupid.toUpperCase().trim().equals("")) {
+			// 设置文档所属的文档组 ID
+			doc.getDoc().setDocgroupid(groupid);
+		}
+		// 获取当前用户可用于撰写文档的文档类型列表
+		List<TypeBrief> types = farmDocTypeManagerImpl.getTypesForWriteDoc(getCurrentUser(session));
+		// 从系统参数中获取允许上传的文件类型字符串，并转换为小写，替换中文逗号为英文逗号
+		String filetypeString = FarmParameterService.getInstance().getParameter("config.doc.upload.types").toLowerCase()
+				.replaceAll("，", ",");
+		// 用于存储处理后的文件类型字符串
+		StringBuffer filetypestrplus = new StringBuffer();
+		// 遍历解析后的文件类型字符串
+		for (String node : parseIds(filetypeString)) {
+			// 如果不是第一个文件类型，添加分隔符
+			if (filetypestrplus.length() > 0) {
+				filetypestrplus.append(";");
+			}
+			// 拼接文件类型字符串
+			filetypestrplus.append("*." + node);
+		}
+		// 将文档类型列表、文档实体、文件类型字符串等数据放入视图模型，并返回创建资源文件页面的视图模型
+		return ViewMode.getInstance().putAttr("types", types).putAttr("doc", doc).putAttr("filetypestr", filetypeString)
+				.putAttr("filetypestrplus", filetypestrplus.toString())
+				.returnModelAndView(ThemesUtil.getThemePath() + "/webfile/creat");
+	}
+
+	/**
+	 * 进入编辑资源文件页面
+	 *
+	 * @param docId   文档 ID
+	 * @param session HTTP 会话对象
+	 * @param request HTTP 请求对象
+	 * @return 包含相关数据的视图模型
+	 */
+	// 映射 /edit 请求路径，处理默认请求（通常为 GET）
+	@RequestMapping("/edit")
+	public ModelAndView editWebfile(String docId, HttpSession session, HttpServletRequest request) {
+		// 定义完整的文档实体对象
+		DocEntire doc = null;
+		try {
+			// 根据文档 ID 和当前用户获取完整的文档实体
+			doc = farmDocManagerImpl.getDoc(docId, getCurrentUser(session));
+		} catch (Exception e) {
+			// 如果发生异常，设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+		// 获取当前用户可用于撰写文档的文档类型列表
+		List<TypeBrief> types = farmDocTypeManagerImpl.getTypesForWriteDoc(getCurrentUser(session));
+		// 从系统参数中获取允许上传的文件类型字符串，并转换为小写，替换中文逗号为英文逗号
+		String filetypeString = FarmParameterService.getInstance().getParameter("config.doc.upload.types").toLowerCase()
+				.replaceAll("，", ",");
+		// 用于存储处理后的文件类型字符串
+		StringBuffer filetypestrplus = new StringBuffer();
+		// 遍历解析后的文件类型字符串
+		for (String node : parseIds(filetypeString)) {
+			// 如果不是第一个文件类型，添加分隔符
+			if (filetypestrplus.length() > 0) {
+				filetypestrplus.append(";");
+			}
+			// 拼接文件类型字符串
+			filetypestrplus.append("*." + node);
+		}
+		// 将完整的文档实体、文档类型列表、文件类型字符串等数据放入视图模型，并返回编辑资源文件页面的视图模型
+		return ViewMode.getInstance().putAttr("doce", doc).putAttr("types", types)
+				.putAttr("filetypestr", filetypeString).putAttr("filetypestrplus", filetypestrplus.toString())
+				.returnModelAndView(ThemesUtil.getThemePath() + "/webfile/edit");
+	}
+
+	/**
+	 * 提交编辑资源文件的表单
+	 *
+	 * @param docid     文档 ID
+	 * @param fileId    文件 ID
+	 * @param knowtype  知识类型
+	 * @param knowtitle 知识标题
+	 * @param knowtag   知识标签
+	 * @param docgroup  文档组
+	 * @param writetype 写入权限类型
+	 * @param readtype  读取权限类型
+	 * @param text      文档内容
+	 * @param editnote  编辑备注
+	 * @param session   HTTP 会话对象
+	 * @return 重定向或错误页面的视图模型
+	 */
+	// 映射 /editCommit 请求路径，处理默认请求（通常为 POST）
+	@RequestMapping("/editCommit")
+	public ModelAndView editCommit(String docid, String fileId, String knowtype, String knowtitle, String knowtag,
+								   String docgroup, String writetype, String readtype, String text, String editnote, HttpSession session) {
+		// 定义完整的文档实体对象
+		DocEntire doc = null;
+		try {
+			// 如果文档组 ID 为 "0"，将其置为 null
+			if (docgroup.equals("0")) {
+				docgroup = null;
+			}
+			// 调用 WCP 网页文件管理服务的编辑方法，更新文档信息
+			doc = wcpWebFileManagerImpl.editWebFile(docid, Arrays.asList(fileId.trim().split(",")), knowtype, knowtitle,
+					knowtag, docgroup, text, POP_TYPE.getEnum(writetype), POP_TYPE.getEnum(readtype), editnote,
+					getCurrentUser(session));
+			// 如果文档需要审核
+			if (doc.getAudit() != null) {
+				// 重定向到审核临时文档页面
+				return ViewMode.getInstance().returnRedirectUrl("/audit/tempdoc.do?auditid=" + doc.getAudit().getId());
+			}
+			// 重定向到文档查看页面
+			return ViewMode.getInstance().returnRedirectUrl("/webdoc/view/Pub" + doc.getDoc().getId() + ".html");
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+
+	/**
+	 * 提交创建资源文件的表单
+	 *
+	 * @param fileId     文件 ID
+	 * @param creattype  创建类型
+	 * @param knowtype   知识类型
+	 * @param knowtitle  知识标题
+	 * @param knowtag    知识标签
+	 * @param text       文档内容
+	 * @param docgroup   文档组
+	 * @param writetype  写入权限类型
+	 * @param readtype   读取权限类型
+	 * @param session    HTTP 会话对象
+	 * @return 包含消息或重定向的视图模型
+	 */
+	// 映射 /addsubmit 请求路径，处理默认请求（通常为 POST）
+	@RequestMapping("/addsubmit")
+	public ModelAndView creatWebFileSubmit(String fileId, String creattype, String knowtype, String knowtitle,
+										   String knowtag, String text, String docgroup, String writetype, String readtype, HttpSession session) {
+		try {
+			// 将文件 ID 字符串按逗号分割并转换为列表
+			List<String> fileids = Arrays.asList(fileId.trim().split(","));
+			// 如果创建类型为 "on"
+			if (creattype != null && creattype.equals("on")) {
+				/** 创建为独立知识 **/
+				// 用于存储文件名和对应文档链接的映射
+				Map<String, String> doclinks = new HashMap<String, String>();
+				// 定义完整的文档实体对象
+				DocEntire doc = null;
+				// 遍历文件 ID 列表
+				for (String fileid : fileids) {
+					// 创建一个只包含当前文件 ID 的列表
+					List<String> fileidlist = new ArrayList<>();
+					fileidlist.add(fileid);
+					// 如果文档组 ID 为 "0"，将其置为 null
+					if (docgroup != null && docgroup.equals("0")) {
+						docgroup = null;
+					}
+					// 根据文件 ID 获取文件名
+					String fileName = farmFileManagerImpl.getFile(fileid).getName();
+					// 调用 WCP 网页文件管理服务的创建方法，创建文档
+					doc = wcpWebFileManagerImpl.creatWebFile(fileidlist, knowtype, fileName, knowtag, docgroup, text,
+							POP_TYPE.getEnum(writetype), POP_TYPE.getEnum(readtype), getCurrentUser(session));
+					// 如果文档需要审核
+					if (doc.getAudit() != null) {
+						// 将文件名和审核临时文档链接存入映射
+						doclinks.put(fileName, "/audit/tempdoc.do?auditid=" + doc.getAudit().getId());
+					} else {
+						// 将文件名和文档查看链接存入映射
+						doclinks.put(fileName, "/webdoc/view/Pub" + doc.getDoc().getId() + ".html");
+					}
+				}
+				// 如果最后一个文档需要审核
+				if (doc.getAudit() != null) {
+					// 设置消息并返回消息页面的视图模型
+					return ViewMode.getInstance().putAttr("MESSAGE", fileids.size() + "个资源文件创建成功，但是需要审核后才能够被他人访问！")
+							.returnModelAndView(ThemesUtil.getThemePath() + "/message");
+				}
+				// 设置消息和文档链接映射，并返回消息页面的视图模型
+				return ViewMode.getInstance().putAttr("MESSAGE", fileids.size() + "个资源文件创建成功！")
+						.putAttr("LINKS", doclinks).returnModelAndView(ThemesUtil.getThemePath() + "/message");
+			} else {
+				/** 创建为一个知识 **/
+				// 定义完整的文档实体对象
+				DocEntire doc = null;
+				// 如果文档组 ID 为 "0"，将其置为 null
+				if (docgroup.equals("0")) {
+					docgroup = null;
+				}
+				// 调用 WCP 网页文件管理服务的创建方法，创建文档
+				doc = wcpWebFileManagerImpl.creatWebFile(fileids, knowtype, knowtitle, knowtag, docgroup, text,
+						POP_TYPE.getEnum(writetype), POP_TYPE.getEnum(readtype), getCurrentUser(session));
+				// 如果文档需要审核
+				if (doc.getAudit() != null) {
+					// 重定向到审核临时文档页面
+					return ViewMode.getInstance()
+							.returnRedirectUrl("/audit/tempdoc.do?auditid=" + doc.getAudit().getId());
+				}
+				// 重定向到文档查看页面
+				return ViewMode.getInstance().returnRedirectUrl("/webdoc/view/Pub" + doc.getDoc().getId() + ".html");
+			}
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 设置错误信息并返回错误页面的视图模型
+			return ViewMode.getInstance().setError(e.toString())
+					.returnModelAndView(ThemesUtil.getThemePath() + "/error");
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/util/HttpDocument.java

@@ -0,0 +1,206 @@
+// 声明包路径
+package com.farm.wcp.util;
+
+// 导入 File 类，用于操作文件
+import java.io.File;
+// 导入 IOException 异常类，用于处理输入输出异常
+import java.io.IOException;
+// 导入 URL 类，用于表示统一资源定位符
+import java.net.URL;
+// 导入 Iterator 接口，用于遍历集合元素
+import java.util.Iterator;
+
+// 导入 Jsoup 的 Connection 类，用于建立 HTTP 连接
+import org.jsoup.Connection;
+// 导入 Jsoup 类，用于解析 HTML 文档
+import org.jsoup.Jsoup;
+// 导入 Jsoup 的 Document 类，用于表示 HTML 文档
+import org.jsoup.nodes.Document;
+// 导入 Jsoup 的 Element 类，用于表示 HTML 元素
+import org.jsoup.nodes.Element;
+// 导入 Jsoup 的 Elements 类，用于表示 HTML 元素集合
+import org.jsoup.select.Elements;
+
+// 导入 HttpResourceHandle 类，用于处理 HTTP 资源
+import com.farm.wcp.know.util.HttpResourceHandle;
+
+/**
+ * 该类用于配合 Jsoup 处理 HTML 文档，提供了对 HTML 文档的各种操作方法
+ *
+ * @author Administrator
+ */
+public class HttpDocument {
+	// 存储 Jsoup 的 Document 对象，代表 HTML 文档
+	private Document document;
+	// 存储 HTML 文档的 URL
+	private URL url;
+	// 定义请求时使用的用户代理字符串，模拟 Firefox 浏览器
+	private static final String AGENT_REQUEST = "Mozilla/5.0 (Windows NT 5.1; rv:11.0) Gecko/20100101 Firefox/11.0";
+
+	/**
+	 * 获取 Jsoup 的 Document 对象
+	 *
+	 * @return 返回存储的 Document 对象
+	 */
+	public Document getDocument() {
+		return document;
+	}
+
+	// 私有构造函数，防止外部直接实例化
+	private HttpDocument() {
+
+	}
+
+	/**
+	 * 删除和内容无关的标签（保留图片）
+	 * 包括 script、textarea、style、a 的 href 属性、input、button、iframe 标签
+	 */
+	public void removeOutContent() {
+		// 删除所有 script 标签
+		document.getElementsByTag("script").remove();
+		// 删除所有 textarea 标签
+		document.getElementsByTag("textarea ").remove();
+		// 删除所有 style 标签
+		document.getElementsByTag("style").remove();
+		// 移除所有 a 标签的 href 属性
+		document.getElementsByTag("a").removeAttr("href");
+		// 删除所有 input 标签
+		document.getElementsByTag("input").remove();
+		// 删除所有 button 标签
+		document.getElementsByTag("button").remove();
+		// 注释掉的代码，原本用于移除 img 标签的 src 属性
+		// document.getElementsByTag("img").removeAttr("src");
+		// 删除所有 iframe 标签
+		document.getElementsByTag("iframe").remove();
+	}
+
+	/**
+	 * 改写页面中的远程资源
+	 *
+	 * @param handle 用于处理 HTTP 资源的对象
+	 */
+	public void rewriteResources(HttpResourceHandle handle) {
+		// 获取文档中所有的 img 标签
+		Elements imgs = document.getElementsByTag("img");
+		// 获取 img 标签集合的迭代器
+		Iterator<Element> imgtor = imgs.iterator();
+		// 遍历所有 img 标签
+		while (imgtor.hasNext()) {
+			// 获取当前的 img 标签元素
+			Element element = imgtor.next();
+			// 存储图片的原始 URL
+			String url = null;
+			// 存储处理后的图片 URL
+			String rUrl = null;
+			// 获取 img 标签的 src 属性值
+			url = element.attr("src");
+			// 如果 src 属性值不为空
+			if (url != null && url.trim().length() > 0) {
+				// 调用 handle 方法处理图片 URL
+				rUrl = handle.handle(url, this.url);
+				// 将 img 标签的 src 属性替换为处理后的 URL
+				element.attr("src", rUrl);
+			}
+		}
+	}
+
+	/**
+	 * 获得 HTML 的字符集
+	 *
+	 * @return 返回 HTML 文档的字符集，如果未找到则默认返回 UTF-8
+	 */
+	public String getCharset() {
+		// 获取文档中所有的 meta 标签
+		Elements meta = document.getElementsByTag("meta");
+		// 遍历所有 meta 标签
+		for (Element node : meta) {
+			// 获取 meta 标签的 content 属性值
+			String attr = node.attr("content");
+			// 如果 content 属性值中包含 "CHARSET"
+			if (attr.toUpperCase().indexOf("CHARSET") >= 0) {
+				// 截取字符集部分
+				String charstr = attr.toUpperCase().substring(
+						attr.toUpperCase().indexOf("=") + 1);
+				// 返回字符集
+				return charstr;
+			}
+		}
+		// 如果未找到字符集信息，默认返回 UTF-8
+		return "UTF-8";
+	}
+
+	/**
+	 * 获取 HTML 文档的标题
+	 *
+	 * @return 返回 HTML 文档的标题文本
+	 */
+	public String getTitle() {
+		// 获取文档中所有的 title 标签
+		Elements Styles = document.getElementsByTag("title");
+		// 返回第一个 title 标签的文本内容
+		return Styles.get(0).text();
+	}
+
+	/**
+	 * 根据 Jsoup 的 Connection 对象实例化 HttpDocument 对象
+	 *
+	 * @param con Jsoup 的 Connection 对象
+	 * @return 返回实例化后的 HttpDocument 对象，如果发生异常则返回 null
+	 */
+	public static HttpDocument instance(Connection con) {
+		// 声明 HttpDocument 对象
+		HttpDocument macDoc = null;
+		try {
+			// 创建 HttpDocument 对象
+			macDoc = new HttpDocument();
+			// 设置 HttpDocument 对象的 URL
+			macDoc.url = con.request().url();
+			// 使用 Connection 对象发送请求并获取 Document 对象
+			macDoc.document = con.userAgent(AGENT_REQUEST).get();
+		} catch (IOException e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+		}
+		// 返回实例化后的 HttpDocument 对象
+		return macDoc;
+	}
+
+	/**
+	 * 根据 HTML 字符串实例化 HttpDocument 对象
+	 *
+	 * @param html HTML 字符串
+	 * @return 返回实例化后的 HttpDocument 对象
+	 */
+	public static HttpDocument instance(String html) {
+		// 声明 HttpDocument 对象
+		HttpDocument macDoc = null;
+		// 创建 HttpDocument 对象
+		macDoc = new HttpDocument();
+		// 使用 Jsoup 解析 HTML 字符串并设置为 Document 对象
+		macDoc.document = Jsoup.parseBodyFragment(html);
+		// 返回实例化后的 HttpDocument 对象
+		return macDoc;
+	}
+
+	/**
+	 * 根据文件实例化 HttpDocument 对象
+	 *
+	 * @param file 文件对象
+	 * @return 返回实例化后的 HttpDocument 对象，如果发生异常则返回 null
+	 */
+	public static HttpDocument instance(File file) {
+		// 声明 HttpDocument 对象
+		HttpDocument macDoc = null;
+		try {
+			// 创建 HttpDocument 对象
+			macDoc = new HttpDocument();
+			// 使用 Jsoup 解析文件内容并设置为 Document 对象，指定字符集为 UTF-8
+			macDoc.document = Jsoup.parse(file, "UTF-8");
+		} catch (IOException e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+		}
+		// 返回实例化后的 HttpDocument 对象
+		return macDoc;
+	}
+}

src/wcp-web/src/main/java/com/farm/wcp/util/ImHistory.java

@@ -0,0 +1,81 @@
+// 声明包路径
+package com.farm.wcp.util;
+
+// 导入 ArrayList 类，用于创建动态数组
+import java.util.ArrayList;
+// 导入 Date 类，用于处理日期和时间
+import java.util.Date;
+// 导入 List 接口，用于表示有序集合
+import java.util.List;
+
+// 导入 HttpSession 类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入 TimeTool 类，用于时间处理
+import com.farm.core.time.TimeTool;
+// 导入 LlmMessage 类，用于表示聊天消息
+import com.farm.llm.utils.LlmMessage;
+// 导入 M_TYPE 枚举，用于表示消息类型
+import com.farm.llm.utils.LlmMessage.M_TYPE;
+
+/**
+ * 该类用于管理聊天记录，提供了添加、清除和获取聊天记录的方法
+ *
+ * @author macpl
+ */
+public class ImHistory {
+	// 定义会话属性名称，用于存储聊天记录列表
+	private static String SESSION_IM_HIS = "SESSION_IM_HIS";
+
+	/**
+	 * 向会话中添加聊天消息
+	 *
+	 * @param session  HTTP 会话对象
+	 * @param message  HTML 格式的消息内容
+	 * @param rawMsg   原始消息内容
+	 * @param type     消息类型，取值为 M_TYPE 枚举中的值（mine|service）
+	 */
+	public static void addMessage(HttpSession session, String message, String rawMsg, M_TYPE type) {
+		// 从会话中获取聊天记录列表，进行类型转换
+		@SuppressWarnings("unchecked")
+		List<LlmMessage> list = (List<LlmMessage>) session.getAttribute(SESSION_IM_HIS);
+		// 如果列表为空
+		if (list == null) {
+			// 创建一个新的 ArrayList 作为聊天记录列表
+			list = new ArrayList<LlmMessage>();
+		}
+		// 创建一个新的 LlmMessage 对象，包含消息内容、消息类型和当前时间
+		list.add(new LlmMessage(message, type, TimeTool.format(new Date(), "yyyy-MM-dd HH:mm")));
+		// 将更新后的聊天记录列表存储到会话中
+		session.setAttribute(SESSION_IM_HIS, list);
+	}
+
+	/**
+	 * 清除会话中的聊天记录
+	 *
+	 * @param session HTTP 会话对象
+	 */
+	public static void clearMessage(HttpSession session) {
+		// 将空的聊天记录列表存储到会话中，实现清除聊天记录的功能
+		session.setAttribute(SESSION_IM_HIS, new ArrayList<LlmMessage>());
+	}
+
+	/**
+	 * 从会话中获取聊天记录列表
+	 *
+	 * @param session HTTP 会话对象
+	 * @return 聊天记录列表，如果会话中没有存储聊天记录，则返回一个空的列表
+	 */
+	public static List<LlmMessage> getMessages(HttpSession session) {
+		// 从会话中获取聊天记录列表，进行类型转换
+		@SuppressWarnings("unchecked")
+		List<LlmMessage> list = (List<LlmMessage>) session.getAttribute(SESSION_IM_HIS);
+		// 如果列表为空
+		if (list == null) {
+			// 返回一个新的空的 ArrayList
+			return new ArrayList<LlmMessage>();
+		}
+		// 返回获取到的聊天记录列表
+		return list;
+	}
+}

src/wcp-web/src/main/java/com/farm/wcp/util/LuceneDocUtil.java

@@ -0,0 +1,82 @@
+// 声明该类所在的包
+package com.farm.wcp.util;
+
+// 导入 Lucene 中用于设置字段索引方式的 Index 类
+import org.apache.lucene.document.Field.Index;
+// 导入 Lucene 中用于设置字段存储方式的 Store 类
+import org.apache.lucene.document.Field.Store;
+
+// 导入文档类型实体类，代表文档的类型信息
+import com.farm.doc.domain.FarmDoctype;
+// 导入完整文档实体类，包含文档的各种信息
+import com.farm.doc.domain.ex.DocEntire;
+// 导入 HTML 工具类，用于处理 HTML 文本
+import com.farm.doc.util.HtmlUtils;
+// 导入自定义的 DocMap 类，用于存储文档的索引元数据
+import com.farm.lucene.adapter.DocMap;
+
+/**
+ * 该类的主要作用是在进行全文检索时，辅助生成索引元数据对象。
+ *
+ * @author Administrator
+ */
+public class LuceneDocUtil {
+	/**
+	 * 根据传入的完整文档实体对象生成一个用于全文检索的索引元数据对象。
+	 *
+	 * @param doc 完整文档实体对象，包含了文档的各种详细信息
+	 * @return 生成的索引元数据对象，包含了文档的各个字段及其索引和存储设置
+	 */
+	public static DocMap getDocMap(DocEntire doc) {
+		// 用于存储文档的文本内容
+		String text = "";
+		// 检查文档的文本信息是否存在
+		if (doc.getTexts() != null) {
+			// 若存在，获取文档的第一个文本内容
+			text = doc.getTexts().getText1();
+		}
+		// 调用 HTML 工具类的方法，去除文本中的 HTML 标签
+		text = HtmlUtils.HtmlRemoveTag(text);
+		// 创建一个 DocMap 对象，以文档的 ID 作为标识
+		DocMap map = new DocMap(doc.getDoc().getId());
+		// 用于存储拼接后的所有上级分类名称
+		String typeAll = "";
+		// 拼接所有上级分类名称，用于索引
+		if (doc.getCurrenttypes() != null) {
+			// 遍历文档当前的所有类型
+			for (FarmDoctype node : doc.getCurrenttypes()) {
+				// 判断是否是第一个类型
+				if (typeAll.equals("")) {
+					// 若是第一个类型，直接赋值
+					typeAll = node.getName();
+				} else {
+					// 若不是第一个类型，用斜杠拼接类型名称
+					typeAll = typeAll + "/" + node.getName();
+				}
+			}
+		}
+		// 将拼接好的所有上级分类名称存入 DocMap 对象，设置为存储且可分析索引
+		map.put("TYPENAME", typeAll, Store.YES, Index.ANALYZED);
+		// 将文档的标签关键字存入 DocMap 对象，设置为存储且可分析索引
+		map.put("TAGKEY", doc.getDoc().getTagkey(), Store.YES, Index.ANALYZED);
+		// 将文档的标题存入 DocMap 对象，设置为存储且可分析索引
+		map.put("TITLE", doc.getDoc().getTitle(), Store.YES, Index.ANALYZED);
+		// 将文档的作者存入 DocMap 对象，设置为存储且可分析索引
+		map.put("AUTHOR", doc.getDoc().getAuthor(), Store.YES, Index.ANALYZED);
+		// 将文档的描述存入 DocMap 对象，设置为存储且可分析索引
+		map.put("DOCDESCRIBE", doc.getDoc().getDocdescribe(), Store.YES, Index.ANALYZED);
+		// 将文档的访问次数存入 DocMap 对象，初始值设为 0，设置为存储且可分析索引
+		map.put("VISITNUM", "0", Store.YES, Index.ANALYZED);
+		// 将文档的发布时间存入 DocMap 对象，设置为存储且可分析索引
+		map.put("PUBTIME", doc.getDoc().getPubtime(), Store.YES, Index.ANALYZED);
+		// 将文档的创建用户 ID 存入 DocMap 对象，设置为存储且可分析索引
+		map.put("USERID", doc.getDoc().getCuser(), Store.YES, Index.ANALYZED);
+		// 将文档的领域类型存入 DocMap 对象，设置为存储且可分析索引
+		map.put("DOMTYPE", doc.getDoc().getDomtype(), Store.YES, Index.ANALYZED);
+		// 将处理后的文档文本内容存入 DocMap 对象，设置为存储且可分析索引
+		map.put("TEXT", text, Store.YES, Index.ANALYZED);
+		// 返回生成好的 DocMap 对象
+		return map;
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/util/ThemesUtil.java

@@ -0,0 +1,24 @@
+// 声明类所在的包
+package com.farm.wcp.util;
+
+// 导入用于获取系统参数的服务类
+import com.farm.parameter.FarmParameterService;
+
+/**
+ * 该类提供了与主题路径相关的工具方法。
+ */
+public class ThemesUtil {
+	/**
+	 * 获取系统配置的主题路径。
+	 *
+	 * 此方法通过调用 FarmParameterService 类的实例来获取名为 "config.sys.web.themes.path" 的系统参数值。
+	 * 该参数值代表了系统中配置的主题路径。
+	 *
+	 * @return 系统配置的主题路径字符串。
+	 */
+	public static String getThemePath() {
+		// 通过单例模式获取 FarmParameterService 实例，并调用其 getParameter 方法获取指定参数的值
+		return FarmParameterService.getInstance().getParameter("config.sys.web.themes.path");
+	}
+}
+

src/wcp-web/src/main/java/com/farm/wcp/util/ZxingTowDCode.java

@@ -0,0 +1,97 @@
+// 声明包路径
+package com.farm.wcp.util;
+
+// 导入 Google ZXing 库中用于表示二维码矩阵的类
+import com.google.zxing.common.BitMatrix;
+
+// 导入用于处理图像 I/O 的类
+import javax.imageio.ImageIO;
+// 导入用于表示文件的类
+import java.io.File;
+// 导入用于表示输出流的类
+import java.io.OutputStream;
+// 导入用于处理 I/O 异常的类
+import java.io.IOException;
+// 导入用于处理图像的类
+import java.awt.image.BufferedImage;
+
+/**
+ * 该类提供了将 ZXing 二维码矩阵转换为 BufferedImage 以及将其写入文件或输出流的工具方法。
+ */
+public class ZxingTowDCode {
+
+	// 定义黑色的 RGB 值
+	private static final int BLACK = 0xFF000000;
+	// 定义白色的 RGB 值
+	private static final int WHITE = 0xFFFFFFFF;
+
+	// 私有构造函数，防止类被实例化
+	private ZxingTowDCode() {
+	}
+
+	/**
+	 * 将 ZXing 的二维码矩阵转换为 BufferedImage 对象。
+	 *
+	 * @param matrix 要转换的二维码矩阵
+	 * @return 转换后的 BufferedImage 对象
+	 */
+	public static BufferedImage toBufferedImage(BitMatrix matrix) {
+		// 获取二维码矩阵的宽度
+		int width = matrix.getWidth();
+		// 获取二维码矩阵的高度
+		int height = matrix.getHeight();
+		// 创建一个新的 BufferedImage 对象，类型为 TYPE_INT_RGB
+		BufferedImage image = new BufferedImage(width, height,
+				BufferedImage.TYPE_INT_RGB);
+		// 遍历二维码矩阵的每一个像素点
+		for (int x = 0; x < width; x++) {
+			for (int y = 0; y < height; y++) {
+				// 根据二维码矩阵中该点的值设置 BufferedImage 中对应点的 RGB 值
+				image.setRGB(x, y, matrix.get(x, y) ? BLACK : WHITE);
+			}
+		}
+		// 返回转换后的 BufferedImage 对象
+		return image;
+	}
+
+	/**
+	 * 将二维码矩阵转换为指定格式的图像并写入文件。
+	 *
+	 * @param matrix  要转换和写入的二维码矩阵
+	 * @param format  图像格式，如 "png", "jpg" 等
+	 * @param file    要写入的文件对象
+	 * @throws IOException 如果写入过程中出现 I/O 错误
+	 */
+	public static void writeToFile(BitMatrix matrix, String format, File file)
+			throws IOException {
+		// 将二维码矩阵转换为 BufferedImage 对象
+		BufferedImage image = toBufferedImage(matrix);
+		// 尝试将 BufferedImage 对象写入文件
+		if (!ImageIO.write(image, format, file)) {
+			// 如果写入失败，抛出 IOException 异常
+			throw new IOException("Could not write an image of format "
+					+ format + " to " + file);
+		}
+	}
+
+	/**
+	 * 将二维码矩阵转换为指定格式的图像并写入输出流。
+	 *
+	 * @param matrix  要转换和写入的二维码矩阵
+	 * @param format  图像格式，如 "png", "jpg" 等
+	 * @param stream  要写入的输出流对象
+	 * @throws IOException 如果写入过程中出现 I/O 错误
+	 */
+	public static void writeToStream(BitMatrix matrix, String format,
+									 OutputStream stream) throws IOException {
+		// 将二维码矩阵转换为 BufferedImage 对象
+		BufferedImage image = toBufferedImage(matrix);
+		// 尝试将 BufferedImage 对象写入输出流
+		if (!ImageIO.write(image, format, stream)) {
+			// 如果写入失败，抛出 IOException 异常
+			throw new IOException("Could not write an image of format "
+					+ format);
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/web/filter/FilterEncoding.java

@@ -0,0 +1,68 @@
+// 声明包路径
+package com.farm.web.filter;
+
+// 导入用于处理输入输出异常的类
+import java.io.IOException;
+
+// 导入 Servlet 过滤器接口
+import javax.servlet.Filter;
+// 导入过滤器链接口，用于将请求传递给下一个过滤器或目标资源
+import javax.servlet.FilterChain;
+// 导入过滤器配置对象，用于获取过滤器的初始化参数
+import javax.servlet.FilterConfig;
+// 导入用于处理 Servlet 异常的类
+import javax.servlet.ServletException;
+// 导入 Servlet 请求接口
+import javax.servlet.ServletRequest;
+// 导入 Servlet 响应接口
+import javax.servlet.ServletResponse;
+
+// 导入应用配置类，用于获取应用的配置信息
+import com.farm.core.config.AppConfig;
+
+/**
+ * 该过滤器用于设置请求的编码格式
+ *
+ * @author WangDong
+ * @date Mar 14, 2010
+ */
+public class FilterEncoding implements Filter {
+
+	/**
+	 * 过滤器销毁时调用的方法，通常用于释放资源
+	 * 目前方法体为空，可根据实际需求添加资源释放逻辑
+	 */
+	public void destroy() {
+		// TODO Auto-generated method stub
+	}
+
+	/**
+	 * 过滤器的核心方法，用于对请求和响应进行处理
+	 *
+	 * @param arg0  Servlet 请求对象
+	 * @param arg1  Servlet 响应对象
+	 * @param arg2  过滤器链对象
+	 * @throws IOException      如果在处理过程中发生输入输出异常
+	 * @throws ServletException 如果在处理过程中发生 Servlet 异常
+	 */
+	public void doFilter(ServletRequest arg0, ServletResponse arg1,
+						 FilterChain arg2) throws IOException, ServletException {
+		// 从应用配置中获取过滤器的编码配置
+		String encode = AppConfig.getString("config.filter.encode");
+		// 设置请求的字符编码为从配置中获取的编码
+		arg0.setCharacterEncoding(encode);
+		// 将请求和响应传递给过滤器链中的下一个过滤器或目标资源
+		arg2.doFilter(arg0, arg1);
+	}
+
+	/**
+	 * 过滤器初始化时调用的方法，用于获取过滤器的配置信息
+	 * 目前方法体为空，可根据实际需求添加初始化逻辑
+	 *
+	 * @param arg0 过滤器配置对象
+	 * @throws ServletException 如果在初始化过程中发生 Servlet 异常
+	 */
+	public void init(FilterConfig arg0) throws ServletException {
+		// TODO Auto-generated method stub
+	}
+}

src/wcp-web/src/main/java/com/farm/web/filter/FilterLogInfo.java

@@ -0,0 +1,99 @@
+// 声明该类所在的包
+package com.farm.web.filter;
+
+// 导入用于处理输入输出异常的类
+import java.io.IOException;
+
+// 导入 Servlet 过滤器接口
+import javax.servlet.Filter;
+// 导入过滤器链接口，用于将请求传递给下一个过滤器或目标 Servlet
+import javax.servlet.FilterChain;
+// 导入过滤器配置对象，用于获取过滤器的初始化参数
+import javax.servlet.FilterConfig;
+// 导入 Servlet 异常类，用于处理 Servlet 相关的异常
+import javax.servlet.ServletException;
+// 导入 Servlet 请求接口，代表客户端的请求
+import javax.servlet.ServletRequest;
+// 导入 Servlet 响应接口，代表服务器的响应
+import javax.servlet.ServletResponse;
+// 导入 HTTP 请求接口，继承自 ServletRequest，用于处理 HTTP 协议的请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 HTTP 会话接口，用于管理用户的会话信息
+import javax.servlet.http.HttpSession;
+
+// 导入 Log4j 的 MDC 类，用于在日志中添加上下文信息
+import org.apache.log4j.MDC;
+
+// 导入登录用户实体类，用于表示已登录的用户
+import com.farm.core.auth.domain.LoginUser;
+// 导入农场系统的常量类，包含一些常用的常量
+import com.farm.web.constant.FarmConstant;
+
+/**
+ * 该过滤器的作用是在日志中添加请求的 IP 地址和用户 ID 信息。
+ * 它会在处理每个请求时，将客户端的 IP 地址和当前登录用户的 ID 存入 MDC 中，方便在日志中记录这些信息。
+ */
+public class FilterLogInfo implements Filter {
+
+	/**
+	 * 过滤器销毁时调用的方法，通常用于释放过滤器所占用的资源。
+	 * 目前此方法为空，若有资源需要释放，可在此处添加相应代码。
+	 */
+	@Override
+	public void destroy() {
+		// TODO Auto-generated method stub
+	}
+
+	/**
+	 * 过滤器的核心方法，用于处理请求和响应。
+	 * 它会在请求被传递给下一个过滤器或目标 Servlet 之前，将客户端的 IP 地址和当前登录用户的 ID 存入 MDC 中。
+	 *
+	 * @param arg0  Servlet 请求对象，代表客户端的请求
+	 * @param arg1  Servlet 响应对象，代表服务器的响应
+	 * @param arg2  过滤器链对象，用于将请求传递给下一个过滤器或目标 Servlet
+	 * @throws IOException      如果在输入输出操作中发生异常
+	 * @throws ServletException 如果在 Servlet 处理过程中发生异常
+	 */
+	@Override
+	public void doFilter(ServletRequest arg0, ServletResponse arg1,
+						 FilterChain arg2) throws IOException, ServletException {
+		// 将 ServletRequest 对象转换为 HttpServletRequest 对象，以便处理 HTTP 相关的请求
+		HttpServletRequest req = (HttpServletRequest) arg0;
+		// 获取当前请求的会话对象
+		HttpSession session = req.getSession();
+		// 将客户端的 IP 地址存入 MDC 中，键为 "IP"
+		MDC.put("IP", arg0.getRemoteAddr());
+		// 检查会话对象是否为空
+		if (session == null) {
+			// 若会话为空，将用户 ID 标记为 "NONE" 存入 MDC 中
+			MDC.put("USERID", "NONE");
+		} else {
+			// 从会话中获取当前登录的用户对象
+			LoginUser user = (LoginUser) session
+					.getAttribute(FarmConstant.SESSION_USEROBJ);
+			// 检查用户对象是否为空
+			if (user == null) {
+				// 若用户对象为空，将用户 ID 标记为 "NONE" 存入 MDC 中
+				MDC.put("USERID", "NONE");
+			} else {
+				// 若用户对象不为空，将用户的 ID 存入 MDC 中
+				MDC.put("USERID", user.getId());
+			}
+		}
+		// 将请求和响应传递给过滤器链中的下一个过滤器或目标 Servlet
+		arg2.doFilter(arg0, arg1);
+	}
+
+	/**
+	 * 过滤器初始化时调用的方法，通常用于获取过滤器的初始化参数。
+	 * 目前此方法为空，若有初始化操作需要执行，可在此处添加相应代码。
+	 *
+	 * @param arg0 过滤器配置对象，用于获取过滤器的初始化参数
+	 * @throws ServletException 如果在初始化过程中发生 Servlet 异常
+	 */
+	@Override
+	public void init(FilterConfig arg0) throws ServletException {
+		// TODO Auto-generated method stub
+	}
+}
+

src/wcp-web/src/main/java/com/farm/web/filter/FilterValidate.java

@@ -0,0 +1,232 @@
+package com.farm.web.filter;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Set;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+
+import org.apache.log4j.Logger;
+
+import com.farm.authority.FarmAuthorityService;
+import com.farm.core.AuthorityService;
+import com.farm.core.ParameterService;
+import com.farm.core.auth.domain.AuthKey;
+import com.farm.core.auth.domain.LoginUser;
+import com.farm.core.auth.util.Urls;
+import com.farm.parameter.FarmParameterService;
+import com.farm.web.constant.FarmConstant;
+import com.farm.web.online.OnlineUserOpImpl;
+import com.farm.web.online.OnlineUserOpInter;
+
+/**
+ * 该过滤器用于对用户请求进行权限验证
+ * @author WangDong
+ * @date Mar 14, 2010
+ */
+public class FilterValidate implements Filter {
+	// 创建日志记录器，用于记录与该过滤器相关的日志信息
+	private static final Logger log = Logger.getLogger(FilterValidate.class);
+
+	/**
+	 * 判断给定的URL是否为需要处理的URL
+	 * @param urlStr 要判断的URL字符串
+	 * @return 如果是需要处理的URL返回true，否则返回false
+	 */
+	private boolean isURL(String urlStr) {
+		// 调用Urls工具类的方法判断URL是否以.do或.html结尾
+		return Urls.isActionByUrl(urlStr, "do") || Urls.isActionByUrl(urlStr, "html");
+	}
+
+	/**
+	 * 过滤器的核心方法，用于处理请求和响应
+	 * @param arg0 客户端请求对象
+	 * @param arg1 服务器响应对象
+	 * @param arg2 过滤器链对象
+	 * @throws IOException 输入输出异常
+	 * @throws ServletException Servlet异常
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)
+			throws IOException, ServletException {
+		// 获取参数服务实例，用于获取系统配置参数
+		ParameterService parameterService = FarmParameterService.getInstance();
+		// 获取请求的上下文路径
+		String path = ((HttpServletRequest) arg0).getContextPath();
+		// 构建基础路径
+		String basePath = arg0.getScheme() + "://" + arg0.getServerName() + ":" + arg0.getServerPort() + path + "/";
+		// 将ServletRequest转换为HttpServletRequest，以便处理HTTP请求
+		HttpServletRequest request = (HttpServletRequest) arg0;
+		// 将ServletResponse转换为HttpServletResponse，以便处理HTTP响应
+		HttpServletResponse response = (HttpServletResponse) arg1;
+		// 获取当前请求的会话对象
+		HttpSession session = request.getSession();
+		// 获取请求的完整URL
+		String requestUrl = request.getRequestURL().toString();
+		// 如果端口为80端口则，将该端口去掉，认为是不需要端口的
+		String formatUrl = Urls.formatUrl(requestUrl,requestUrl.indexOf(":")<8?basePath.replace(":80/","/"):basePath);
+		// 用于存储URL的操作键
+		String key = null;
+		// 用于存储当前登录用户对象
+		LoginUser currentUser = null;
+		// 用于存储权限验证的关键信息
+		AuthKey authkey = null;
+		{
+			// 不是后台请求直接运行访问
+			if (!isURL(formatUrl)) {
+				// 如果不是需要处理的URL，直接放行请求
+				arg2.doFilter(arg0, arg1);
+				return;
+			}
+		}
+		{
+			// 组织URL参数
+			// 从格式化后的URL中提取操作键
+			key = Urls.getActionKey(formatUrl);
+			// 从会话中获取当前登录用户对象
+			currentUser = (LoginUser) session.getAttribute(FarmConstant.SESSION_USEROBJ);
+			// 获取权限服务实例
+			AuthorityService authority = FarmAuthorityService.getInstance();
+			// 根据操作键获取权限验证信息
+			authkey = authority.getAuthKey(key);
+		}
+		{
+			// 如果是不检查则任何连接都可执行
+			if (parameterService.getParameter("config.auth.check.url").equals("false")) {
+				// 放开就是对权限不做验证
+				// 如果配置为不进行权限检查，直接放行请求
+				arg2.doFilter(arg0, arg1);
+				return;
+			}
+		}
+		{
+			// 权限是否被定义为禁用
+			if (authkey != null && !authkey.isUseAble()) {
+				// 如果权限被禁用，返回405错误并给出提示信息
+				response.sendError(405, "当前用户没有权限请求该资源!");
+				return;
+			}
+		}
+		// 从操作键中提取子键
+		String subKey = Urls.getActionSubKey(key);
+		{
+			// 是否可以直接访问
+			// 未被定义和不需要登录的均可以直接访问
+			if (authkey != null && !authkey.isLogin()) {
+				// 如果权限不需要登录，直接放行请求
+				arg2.doFilter(arg0, arg1);
+				return;
+			}
+			// 判断是否需要用户权限认证
+			// 获取不需要权限认证的URL前缀配置
+			String prefix = parameterService.getParameter("config.url.free.path.prefix");
+			if (prefix != null && subKey.indexOf("/" + prefix) == 0) {
+				// 如果子键以配置的前缀开头，直接放行请求
+				arg2.doFilter(arg0, arg1);
+				return;
+			}
+		}
+		{
+			// 判断是否是登录即可访问
+			// 获取登录后可访问的URL前缀配置
+			String prefix = parameterService.getParameter("config.url.login.path.prefix");
+			if (prefix != null && subKey.indexOf("/" + prefix) == 0) {
+				if (isURL(formatUrl)) {
+					if (currentUser == null) {
+						// 如果用户未登录，重定向到默认首页
+						response.sendRedirect(parameterService.getParameter("config.index.defaultpage"));
+						return;
+					} else {
+						// 如果用户已登录，直接放行请求
+						arg2.doFilter(arg0, arg1);
+						return;
+					}
+				}
+			}
+			if (authkey != null && authkey.isLogin() && !authkey.isCheck()) {
+				// 如果权限需要登录但不需要检查，直接放行请求
+				arg2.doFilter(arg0, arg1);
+				return;
+			}
+		}
+		{
+			// 处理登录操作
+			// 获取登录页面的URL配置，并分割成数组
+			String[] urls = parameterService.getParameter("config.url.login.indexs").split(",");
+			if (isURL(formatUrl)) {
+				// 如果是用户执行登录操作登录就放过
+				if (Arrays.asList(urls).contains(key)) {
+					// 如果当前请求的操作键是登录页面的URL，直接放行请求
+					arg2.doFilter(arg0, arg1);
+					return;
+				}
+			}
+		}
+		{
+			// 处理未登录用户---让其登录
+			if (isURL(formatUrl)) {
+				if (currentUser == null) {
+					if (request.getMethod().equals("GET")) {
+						// 如果是GET请求，将当前请求的URL和参数存储到会话中
+						session.setAttribute(parameterService.getParameter("farm.constant.session.key.go.url"),
+								requestUrl + "?" + Urls.getUrlParameters(request));
+					}
+					// 重定向到登录页面
+					response.sendRedirect(basePath + parameterService.getParameter("config.url.login"));
+					return;
+				}
+			}
+		}
+		{
+			// 处理--online--用户在线
+			// 创建在线用户操作实例
+			OnlineUserOpInter ouop = OnlineUserOpImpl.getInstance(request.getRemoteAddr(), currentUser.getLoginname(),
+					session);
+			if (parameterService.getParameter("config.auth.multi.user").equals("false")) {
+				// 如果不允许多用户登录，处理用户访问
+				ouop.userVisitHandle();
+			}
+		}
+		// 验证登录用户权限(用户是否有该权限)
+		{
+			// 从会话中获取用户拥有的操作权限集合
+			Set<String> usraction = ((Set<String>) request.getSession().getAttribute(FarmConstant.SESSION_USERACTION));
+			if (authkey != null && !usraction.contains(key)) {
+				// 如果用户没有该操作权限，记录日志并返回405错误
+				log.info("用户未经授权访问'" + authkey.getTitle() + "(" + key + ")'被拦截");
+				response.sendError(405, "当前用户没有权限请求该资源!");
+				return;
+			}
+		}
+		// 非受管的权限可以直接登录
+		// 放行请求
+		arg2.doFilter(arg0, arg1);
+		return;
+	}
+
+	// -----------------------------------------------------------
+	/**
+	 * 过滤器初始化方法，在过滤器启动时调用
+	 * @param arg0 过滤器配置对象
+	 * @throws ServletException Servlet异常
+	 */
+	@Override
+	public void init(FilterConfig arg0) throws ServletException {
+	}
+
+	/**
+	 * 过滤器销毁方法，在过滤器关闭时调用
+	 */
+	@Override
+	public void destroy() {
+	}
+}

src/wcp-web/src/main/java/com/farm/web/init/InitParameter.java

@@ -0,0 +1,98 @@
+// 声明该类所在的包
+package com.farm.web.init;
+
+// 导入 DecimalFormat 类，用于格式化数字
+import java.text.DecimalFormat;
+
+// 导入 ServletContext 类，用于表示 Servlet 上下文
+import javax.servlet.ServletContext;
+
+// 导入常量变量服务实现类，用于注册常量
+import com.farm.parameter.service.impl.ConstantVarService;
+// 导入属性文件服务实现类，用于注册配置文件
+import com.farm.parameter.service.impl.PropertiesFileService;
+// 导入农场系统的常量类，包含一些常用的常量
+import com.farm.web.constant.FarmConstant;
+// 导入 Servlet 初始化任务接口
+import com.farm.web.task.ServletInitJobInter;
+
+/**
+ * 该类实现了 ServletInitJobInter 接口，用于在 Servlet 初始化时执行一些初始化任务，
+ * 主要包括注册常量、注册配置文件以及记录 JVM 内存信息。
+ */
+public class InitParameter implements ServletInitJobInter {
+
+	/**
+	 * 执行初始化任务的方法，在 Servlet 初始化时被调用。
+	 *
+	 * @param context Servlet 上下文对象，用于获取 Servlet 相关的信息
+	 */
+	@Override
+	public void execute(ServletContext context) {
+		// 注册常量，将 FarmConstant 中的常量注册到 ConstantVarService 中
+		// 注册登录时间的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.logintime.", FarmConstant.SESSION_LOGINTIME);
+		// 注册当前组织的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.current.org", FarmConstant.SESSION_ORG);
+		// 注册当前角色的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.current.roles", FarmConstant.SESSION_ROLES);
+		// 注册当前用户操作的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.current.actions", FarmConstant.SESSION_USERACTION);
+		// 注册当前用户菜单的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.current.menu", FarmConstant.SESSION_USERMENU);
+		// 注册当前用户对象的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.current.user", FarmConstant.SESSION_USEROBJ);
+		// 注册当前用户照片的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.current.userphoto",
+				FarmConstant.SESSION_USERPHOTO);
+		// 注册跳转 URL 的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.go.url", FarmConstant.SESSION_GO_URL);
+		// 注册来源 URL 的会话键常量
+		ConstantVarService.registConstant("farm.constant.session.key.from.url", FarmConstant.SESSION_FROM_URL);
+		// 注册菜单树编码单元长度的常量
+		ConstantVarService.registConstant("farm.constant.app.treecodelen",
+				String.valueOf(FarmConstant.MENU_TREECODE_UNIT_LENGTH));
+		// 注册 Web 应用根路径的常量
+		ConstantVarService.registConstant("farm.constant.webroot.path", context.getRealPath(""));
+
+		// 注册配置文件，将不同的配置文件注册到 PropertiesFileService 中
+		PropertiesFileService.registConstant("config");
+		PropertiesFileService.registConstant("llm");
+		PropertiesFileService.registConstant("wda");
+		PropertiesFileService.registConstant("indexConfig");
+		PropertiesFileService.registConstant("jdbc");
+		PropertiesFileService.registConstant("document");
+		PropertiesFileService.registConstant("cache");
+		PropertiesFileService.registConstant("webapp");
+		PropertiesFileService.registConstant("i18n");
+		PropertiesFileService.registConstant("about");
+		PropertiesFileService.registConstant("rmi");
+		PropertiesFileService.registConstant("email");
+
+		// 调用 memory 方法记录 JVM 内存信息
+		memory();
+	}
+
+	/**
+	 * 记录 JVM 内存信息的方法，将 JVM 的总内存、最大内存和空闲内存信息注册到 ConstantVarService 中。
+	 */
+	private static void memory() {
+		// 创建一个 DecimalFormat 对象，用于格式化内存大小为两位小数
+		DecimalFormat df = new DecimalFormat("0.00");
+		// 获取 JVM 的总内存
+		long totalMem = Runtime.getRuntime().totalMemory();
+		// 将 JVM 总内存信息注册到 ConstantVarService 中，单位为 MB
+		ConstantVarService.registConstant("farm.jvm.memory.total", df.format(totalMem / 1024 / 1024) + " MB");
+
+		// 获取 JVM 的最大内存
+		long maxMem = Runtime.getRuntime().maxMemory();
+		// 将 JVM 最大内存信息注册到 ConstantVarService 中，单位为 MB
+		ConstantVarService.registConstant("farm.jvm.memory.max", df.format(maxMem / 1024 / 1024) + " MB");
+
+		// 获取 JVM 的空闲内存
+		long freeMem = Runtime.getRuntime().freeMemory();
+		// 将 JVM 空闲内存信息注册到 ConstantVarService 中，单位为 MB
+		ConstantVarService.registConstant("farm.jvm.memory.free", df.format(freeMem / 1024 / 1024) + " MB");
+	}
+}
+

src/wcp-web/src/main/java/com/farm/web/init/InitRmiInter.java

@@ -0,0 +1,83 @@
+// 声明该类所在的包
+package com.farm.web.init;
+
+// 导入用于处理格式错误的 URL 异常的类
+import java.net.MalformedURLException;
+// 导入用于处理通道已经绑定异常的类
+import java.nio.channels.AlreadyBoundException;
+// 导入 RMI 命名服务相关的类，用于在 RMI 中绑定和查找远程对象
+import java.rmi.Naming;
+// 导入用于处理远程方法调用异常的类
+import java.rmi.RemoteException;
+// 导入用于定位 RMI 注册表的类
+import java.rmi.registry.LocateRegistry;
+
+// 导入 Servlet 上下文类，代表整个 Web 应用程序
+import javax.servlet.ServletContext;
+
+// 导入 Log4j 的日志记录器类，用于记录程序运行时的日志信息
+import org.apache.log4j.Logger;
+
+// 导入参数服务接口
+import com.farm.core.ParameterService;
+// 导入农场参数服务类，用于获取系统配置参数
+import com.farm.parameter.FarmParameterService;
+// 导入 WCP 应用的远程接口
+import com.farm.wcp.api.WcpAppInter;
+// 导入 WDA 应用的远程接口
+import com.farm.wda.inter.WdaAppInter;
+// 导入验证过滤器类
+import com.farm.web.filter.FilterValidate;
+// 导入 WCP 应用的实现类
+import com.farm.web.rmi.impl.WcpAppImpl;
+// 导入 Servlet 初始化任务接口
+import com.farm.web.task.ServletInitJobInter;
+
+/**
+ * 该类实现了 ServletInitJobInter 接口，用于在 Servlet 初始化时启动 RMI（远程方法调用）服务。
+ */
+public class InitRmiInter implements ServletInitJobInter {
+	// 创建一个日志记录器，用于记录与该类相关的日志信息
+	private static final Logger log = Logger.getLogger(InitRmiInter.class);
+
+	/**
+	 * 该方法在 Servlet 初始化时执行，用于启动 RMI 服务。
+	 *
+	 * @param context Servlet 上下文对象，可用于获取 Web 应用的相关信息
+	 */
+	@Override
+	public void execute(ServletContext context) {
+		try {
+			// 从农场参数服务中获取配置项 "config.local.rmi.state" 的值，并转换为大写
+			// 若该值为 "FALSE"，则不启动 RMI 服务，直接返回
+			if (FarmParameterService.getInstance().getParameter("config.local.rmi.state").toUpperCase().equals("FALSE")) {
+				return;
+			}
+			// 从农场参数服务中获取配置项 "config.local.rmi.port" 的值，并转换为整数类型
+			int port = Integer.valueOf(FarmParameterService.getInstance().getParameter("config.local.rmi.port"));
+			// 构建 RMI 服务的 URL，格式为 rmi://127.0.0.1:端口号/wcpapp
+			String rui = "rmi://127.0.0.1:" + port + "/wcpapp";
+			// 创建 WcpAppInter 接口的实现类实例
+			WcpAppInter wda = new WcpAppImpl();
+			// 创建指定端口的 RMI 注册表
+			LocateRegistry.createRegistry(port);
+			// 将 WcpAppInter 接口的实现类实例绑定到指定的 RMI URL 上
+			Naming.rebind(rui, wda);
+			// 记录日志，表明 RMI 服务已成功启动，并输出服务的 URL
+			log.info("启动RMI服务" + rui);
+		} catch (RemoteException e) {
+			// 若在创建远程对象时发生异常，输出错误信息并打印异常堆栈信息
+			System.out.println("创建远程对象发生异常！");
+			e.printStackTrace();
+		} catch (AlreadyBoundException e) {
+			// 若发生重复绑定对象的异常，输出错误信息并打印异常堆栈信息
+			System.out.println("发生重复绑定对象异常！");
+			e.printStackTrace();
+		} catch (MalformedURLException e) {
+			// 若 RMI URL 格式错误，输出错误信息并打印异常堆栈信息
+			System.out.println("发生URL畸形异常！");
+			e.printStackTrace();
+		}
+	}
+}
+

src/wcp-web/src/main/java/com/farm/web/rmi/impl/WcpAppImpl.java

@@ -0,0 +1,184 @@
+package com.farm.web.rmi.impl;
+
+// 导入远程异常类，用于处理 RMI 调用过程中可能出现的异常
+import java.rmi.RemoteException;
+// 导入单播远程对象类，是实现 RMI 服务的基础类
+import java.rmi.server.UnicastRemoteObject;
+// 导入 HashMap 类，用于存储键值对数据
+import java.util.HashMap;
+// 导入 List 接口，用于存储一组对象
+import java.util.List;
+// 导入 Map 接口，用于存储键值对映射
+import java.util.Map;
+
+// 导入农场权限服务类
+import com.farm.authority.FarmAuthorityService;
+// 导入登录用户实体类
+import com.farm.core.auth.domain.LoginUser;
+// 导入数据结果类，用于封装查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入文档完整信息实体类
+import com.farm.doc.domain.ex.DocEntire;
+// 导入文档类型简要信息实体类
+import com.farm.doc.domain.ex.TypeBrief;
+// 导入农场文档管理接口
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入农场文档操作权限接口及权限类型枚举
+import com.farm.doc.server.FarmDocOperateRightInter.POP_TYPE;
+// 导入农场文档类型管理接口
+import com.farm.doc.server.FarmDocTypeInter;
+// 导入农场文件索引管理接口
+import com.farm.doc.server.FarmFileIndexManagerInter;
+// 导入农场文件管理接口
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 Spring 工具类，用于获取 Spring 容器中的 Bean
+import com.farm.util.spring.BeanFactory;
+// 导入 Wcp 应用接口
+import com.farm.wcp.api.WcpAppInter;
+// 导入文档创建错误异常类
+import com.farm.wcp.api.exception.DocCreatErrorExcepiton;
+// 导入结果实体类
+import com.farm.wcp.domain.Results;
+// 导入知识服务接口
+import com.farm.wcp.know.service.KnowServiceInter;
+
+// 定义 WcpAppImpl 类，继承 UnicastRemoteObject 并实现 WcpAppInter 接口
+public class WcpAppImpl extends UnicastRemoteObject implements WcpAppInter {
+	// 构造函数，抛出 RemoteException 异常
+	public WcpAppImpl() throws RemoteException {
+		// 调用父类的构造函数
+		super();
+	}
+
+	// 定义农场文件索引管理实现类对象，通过 Spring 工厂获取 Bean
+	private FarmFileIndexManagerInter farmFileIndexManagerImpl = (FarmFileIndexManagerInter) BeanFactory
+			.getBean("farmFileIndexManagerImpl");
+
+	// 定义农场文件管理实现类对象，通过 Spring 工厂获取 Bean
+	private FarmFileManagerInter farmFileManagerImpl = (FarmFileManagerInter) BeanFactory
+			.getBean("farmFileManagerImpl");
+
+	// 定义农场文档管理实现类对象，通过 Spring 工厂获取 Bean
+	private FarmDocManagerInter farmDocManagerImpl = (FarmDocManagerInter) BeanFactory.getBean("farmDocManagerImpl");
+	// 定义知识服务实现类对象，通过 Spring 工厂获取 Bean
+	private KnowServiceInter KnowServiceImpl = (KnowServiceInter) BeanFactory.getBean("knowServiceImpl");
+
+	// 定义农场文档类型管理实现类对象，通过 Spring 工厂获取 Bean
+	private FarmDocTypeInter farmDocTypeManagerImpl = (FarmDocTypeInter) BeanFactory.getBean("farmDocTypeManagerImpl");
+
+	// 定义序列化版本号
+	private static final long serialVersionUID = 1L;
+
+	/**
+	 * 创建 HTML 知识文档
+	 * @param knowtitle 知识文档标题
+	 * @param knowtypeId 知识文档类型 ID
+	 * @param text 知识文档内容
+	 * @param knowtag 知识文档标签
+	 * @param currentUserId 当前用户 ID
+	 * @return 新创建文档的 ID
+	 * @throws RemoteException 远程调用异常
+	 * @throws DocCreatErrorExcepiton 文档创建错误异常
+	 */
+	@Override
+	public String creatHTMLKnow(String knowtitle, String knowtypeId, String text, String knowtag, String currentUserId)
+			throws RemoteException, DocCreatErrorExcepiton {
+		// 定义文档完整信息对象
+		DocEntire doc = null;
+		try {
+			// 调用知识服务的创建知识方法
+			doc = KnowServiceImpl.creatKnow(knowtitle, knowtypeId, text, knowtag, POP_TYPE.PUB, POP_TYPE.PUB, null,
+					null);
+		} catch (Exception e) {
+			// 捕获异常并抛出文档创建错误异常
+			throw new DocCreatErrorExcepiton(e);
+		}
+		// 返回新创建文档的 ID
+		return doc.getDoc().getId();
+	}
+
+	/**
+	 * 获取指定类型的文档列表
+	 * @param typeid 文档类型 ID
+	 * @param pagesize 每页显示的文档数量
+	 * @param currentpage 当前页码
+	 * @param loginname 登录用户名
+	 * @return 包含文档列表的结果对象
+	 * @throws RemoteException 远程调用异常
+	 */
+	@Override
+	public Results getTypeDocs(String typeid, int pagesize, int currentpage, String loginname) throws RemoteException {
+		// 根据登录名获取登录用户对象
+		LoginUser user = FarmAuthorityService.getInstance().getUserByLoginName(loginname);
+		// 调用文档类型管理接口的方法获取指定类型的文档数据结果
+		DataResult docs = farmDocTypeManagerImpl.getTypeDocs(user, typeid, pagesize, currentpage);
+		// 创建结果对象
+		Results result = new Results();
+		// 设置结果对象的文档列表
+		result.setList(docs.getResultList());
+		// 设置结果对象的当前页码
+		result.setCurrentpage(currentpage);
+		// 设置结果对象的每页显示数量
+		result.setPagesize(pagesize);
+		// 设置结果对象的总记录数
+		result.setTotalsize(docs.getTotalSize());
+		// 返回结果对象
+		return result;
+	}
+
+	/**
+	 * 获取所有文档类型信息
+	 * @param loginname 登录用户名
+	 * @return 包含文档类型信息的结果对象
+	 * @throws RemoteException 远程调用异常
+	 */
+	@Override
+	public Results getAllTypes(String loginname) throws RemoteException {
+		// 根据登录名获取登录用户对象
+		LoginUser user = FarmAuthorityService.getInstance().getUserByLoginName(loginname);
+		// 调用文档类型管理接口的方法获取可供阅读文档的公开类型列表
+		List<TypeBrief> types = farmDocTypeManagerImpl.getPopTypesForReadDoc(user);
+		// 创建结果对象
+		Results result = new Results();
+		// 遍历文档类型列表
+		for (TypeBrief node : types) {
+			// 创建一个 HashMap 用于存储文档类型信息
+			Map<String, Object> map = new HashMap<>();
+			// 存储文档类型名称
+			map.put("NAME", node.getName());
+			// 存储文档类型 ID
+			map.put("ID", node.getId());
+			// 存储文档类型父 ID
+			map.put("PARENTID", node.getParentid());
+			// 存储文档类型相关数量
+			map.put("NUM", node.getNum());
+			// 存储文档类型
+			map.put("TYPE", node.getType());
+			// 将文档类型信息添加到结果对象的列表中
+			result.getList().add(map);
+		}
+		// 设置结果对象的当前页码为 0
+		result.setCurrentpage(0);
+		// 设置结果对象的每页显示数量为 1
+		result.setPagesize(1);
+		// 设置结果对象的总记录数为文档类型列表的大小
+		result.setTotalsize(types.size());
+		// 返回结果对象
+		return result;
+	}
+
+	/**
+	 * 运行 Lucene 索引
+	 * @param fileid 文件 ID
+	 * @param docid 文档 ID
+	 * @param text 文本内容
+	 * @throws RemoteException 远程调用异常
+	 */
+	@SuppressWarnings("deprecation")
+	@Override
+	public void runLuceneIndex(String fileid, String docid, String text) throws RemoteException {
+		// 调用文件索引管理接口的方法添加文件的 Lucene 索引
+		farmFileIndexManagerImpl.addFileLuceneIndex(fileid, farmDocManagerImpl.getDoc(docid), text);
+	}
+
+}