src

src/wcp-parameter/pom.xml

@@ -0,0 +1,89 @@
+<!-- 定义 Maven 项目对象模型（POM）文件，使用 Maven 4.0.0 版本的规范 -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<!-- 指定 POM 模型的版本，固定为 4.0.0 -->
+	<modelVersion>4.0.0</modelVersion>
+	<!-- 定义项目的组 ID，通常是公司或组织的反向域名 -->
+	<groupId>com.farm</groupId>
+	<!-- 定义项目的唯一标识符，即项目的名称 -->
+	<artifactId>wcp-parameter</artifactId>
+	<!-- 定义项目的版本号，使用属性 ${wcp.version} 进行引用 -->
+	<version>${wcp.version}</version>
+	<!-- 定义项目的名称，用于描述项目 -->
+	<name>参数系统</name>
+	<!-- 定义项目的属性，可在 POM 文件中其他地方引用 -->
+	<properties>
+		<!-- 定义项目的版本号为 3.2.0 -->
+		<wcp.version>3.2.0</wcp.version>
+		<!-- 注释说明该属性是文件拷贝时的编码 -->
+		<!-- 定义项目构建时源文件的编码为 UTF-8 -->
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<!-- 定义项目报告输出的编码为 UTF-8 -->
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+		<!-- 注释说明该属性是编译时的编码 -->
+		<!-- 定义 Maven 编译器的编码为 UTF-8 -->
+		<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+	</properties>
+	<!-- 定义项目的依赖项，即项目所依赖的其他库 -->
+	<dependencies>
+		<!-- 定义一个依赖项 -->
+		<dependency>
+			<!-- 依赖项的组 ID -->
+			<groupId>com.farm</groupId>
+			<!-- 依赖项的唯一标识符 -->
+			<artifactId>farm-core</artifactId>
+			<!-- 依赖项的版本号，使用属性 ${wcp.version} 进行引用 -->
+			<version>${wcp.version}</version>
+			<!-- 定义排除依赖项中的某些子依赖 -->
+			<exclusions>
+				<!-- 定义一个排除的子依赖 -->
+				<exclusion>
+					<!-- 排除依赖项的组 ID -->
+					<groupId>javax.servlet.jsp</groupId>
+					<!-- 排除依赖项的唯一标识符 -->
+					<artifactId>jsp-api</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+	</dependencies>
+	<!-- 定义项目的构建配置 -->
+	<build>
+		<!-- 定义项目使用的插件 -->
+		<plugins>
+			<!-- 定义一个插件 -->
+			<plugin>
+				<!-- 插件的唯一标识符 -->
+				<artifactId>maven-compiler-plugin</artifactId>
+				<!-- 插件的配置信息 -->
+				<configuration>
+					<!-- 定义 Java 源代码的版本为 1.8 -->
+					<source>1.8</source>
+					<!-- 定义编译生成的字节码版本为 1.8 -->
+					<target>1.8</target>
+				</configuration>
+			</plugin>
+			<!-- 定义另一个插件 -->
+			<plugin>
+				<!-- 插件的组 ID -->
+				<groupId>org.apache.maven.plugins</groupId>
+				<!-- 插件的唯一标识符 -->
+				<artifactId>maven-jar-plugin</artifactId>
+				<!-- 插件的版本号 -->
+				<version>2.1</version>
+				<!-- 插件的配置信息 -->
+				<configuration>
+					<!-- 定义 JAR 文件的归档配置 -->
+					<archive>
+						<!-- 定义 JAR 文件的清单配置 -->
+						<manifest>
+							<!-- 是否添加默认的实现条目到清单文件中，设置为 true 表示添加 -->
+							<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+							<!-- 是否添加默认的规范条目到清单文件中，设置为 true 表示添加 -->
+							<addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+						</manifest>
+					</archive>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>

src/wcp-parameter/src/main/java/com/farm/log4j/appender/FarmDbAppender.java

@@ -0,0 +1,57 @@
+package com.farm.log4j.appender;
+// 导入org.apache.log4j包中的AppenderSkeleton类，AppenderSkeleton是log4j中用于创建自定义Appender的基类
+import org.apache.log4j.AppenderSkeleton;
+// 导入org.apache.log4j包中的MDC类，MDC（Mapped Diagnostic Context）用于在日志记录中存储和检索线程相关的诊断信息
+import org.apache.log4j.MDC;
+// 导入org.apache.log4j.spi包中的LoggingEvent类，LoggingEvent表示日志事件，包含了日志记录的相关信息
+import org.apache.log4j.spi.LoggingEvent;
+
+import com.farm.parameter.service.AloneApplogServiceInter;
+import com.farm.util.spring.BeanFactory;
+
+// 定义一个名为FarmDbAppender的类，它继承自AppenderSkeleton，用于实现自定义的日志Appender
+public class FarmDbAppender extends AppenderSkeleton {
+
+	// 重写父类AppenderSkeleton的append方法，该方法用于处理实际的日志事件
+	@Override
+	protected void append(LoggingEvent arg0) {
+		// 从MDC中获取名为"USERID"的用户ID信息，如果不存在则设置为"NONE"
+		String userid = MDC.get("USERID") != null ? MDC.get("USERID")
+				.toString() : "NONE";
+		// 从MDC中获取名为"IP"的IP地址信息，如果不存在则设置为"NONE"
+		String ip = MDC.get("IP") != null ? MDC.get("IP").toString() : "NONE";
+
+		// 获取日志事件中的消息内容，如果消息内容为空则设置为空字符串
+		String message = arg0.getMessage() != null ? arg0.getMessage()
+				.toString() : "";
+
+		// 如果消息长度超过512个字符，则截取前512个字符并添加省略号
+		if (message.length() > 512) {
+			message = message.substring(0, 512) + "... ...";
+		}
+		try {
+			// 从Spring的BeanFactory中获取名为"aloneApplogServiceImpl"的Bean实例，并将其强转为AloneApplogServiceInter类型
+			AloneApplogServiceInter logService = (AloneApplogServiceInter) BeanFactory
+					.getBean("aloneApplogServiceImpl");
+			// 调用AloneApplogServiceInter接口的log方法，将日志相关信息（消息、用户ID、日志级别、方法名、类名、IP地址）记录到日志中
+			logService.log(message, userid, arg0.getLevel().toString(), arg0
+					.getLocationInformation().getMethodName(), arg0
+					.getLocationInformation().getClassName(), ip);
+		} catch (Exception e) {
+			// 如果在记录日志过程中发生异常，在控制台输出错误信息，提示日志系统异常并包含出错的日志消息
+			System.out.println("ERROR:日志系统异常，请修复!log error( " + message + ")");
+		}
+	}
+
+	// 重写父类AppenderSkeleton的close方法，这里简单返回，不进行实际的关闭操作
+	@Override
+	public void close() {
+		return;
+	}
+
+	// 重写父类AppenderSkeleton的requiresLayout方法，返回false表示该Appender不需要布局
+	@Override
+	public boolean requiresLayout() {
+		return false;
+	}
+}}

src/wcp-parameter/src/main/java/com/farm/parameter/FarmParameterService.java

@@ -0,0 +1,167 @@
+package com.farm.parameter;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.commons.lang.StringUtils;
+
+import com.farm.core.ParameterService;
+import com.farm.parameter.service.DictionaryEntityServiceInter;
+import com.farm.parameter.service.ParameterServiceInter;
+import com.farm.parameter.service.impl.ConstantVarService;
+import com.farm.parameter.service.impl.PropertiesFileService;
+import com.farm.util.spring.BeanFactory;
+
+/**
+ * 框架系统参数服务
+ * 
+ * @author Administrator
+ * 
+ */
+public class FarmParameterService implements ParameterService {
+	private static ParameterServiceInter parametersLocal;
+	private static DictionaryEntityServiceInter dictionaryentitysLocal;
+	private static ParameterService localstatic;
+
+	/**
+	 * @return
+	 */
+	public static ParameterService getInstance() {
+		if (localstatic == null) {
+			localstatic = new FarmParameterService();
+		}
+		return localstatic;
+	}
+
+	private ParameterServiceInter getParameterService() {
+		if (parametersLocal == null) {
+			parametersLocal = (ParameterServiceInter) BeanFactory
+					.getBean("parameterServiceImpl");
+		}
+		return parametersLocal;
+	}
+
+	private DictionaryEntityServiceInter getDictionaryEntityService() {
+		if (dictionaryentitysLocal == null) {
+			dictionaryentitysLocal = (DictionaryEntityServiceInter) BeanFactory
+					.getBean("dictionaryEntityServiceImpl");
+		}
+		return dictionaryentitysLocal;
+	}
+
+	// 设置属性文件的方法，接受一个包含属性文件名称的列表作为参数
+	public void setPropertiesFiles(List<String> propertiesFiles) {
+		// 遍历属性文件名称列表
+		for (String name : propertiesFiles) {
+			// 调用 PropertiesFileService 的 registConstant 方法注册属性文件
+			if (PropertiesFileService.registConstant(name)) {
+				// 如果注册成功，打印注册成功的信息
+				System.out
+						.println("注册配置文件:"
+								+ name
+								+ ".properties(com.farm.parameter.FarmParameterService)");
+			}
+		}
+	}
+
+	// 重写 getDictionary 方法，用于根据键获取字典映射
+	@Override
+	public Map<String, String> getDictionary(String key) {
+		// 调用 getDictionaryEntityService 方法获取字典实体服务，并调用其 getDictionary 方法获取字典映射
+		return getDictionaryEntityService().getDictionary(key);
+	}
+
+	// 重写 getDictionaryList 方法，用于根据键获取字典列表（键值对条目列表）
+	@Override
+	public List<Entry<String, String>> getDictionaryList(String key) {
+		// 调用 getDictionaryEntityService 方法获取字典实体服务，并调用其 getDictionaryList 方法获取字典列表
+		return getDictionaryEntityService().getDictionaryList(key);
+	}
+
+	// 重写 getParameter 方法，用于根据键获取参数值
+	@Override
+	public String getParameter(String key) {
+		// 去除键两端的空格
+		key = key.trim();
+		// 首先尝试从参数服务中获取参数值（先找用户参数和系统参数）
+		String value = getParameterService().getValue(key);
+		// 如果获取到的参数值不为 null，则直接返回该值
+		if (value != null) {
+			return value;
+		}
+		// 如果在参数服务中未获取到参数值，再尝试从属性文件中获取参数值
+		value = PropertiesFileService.getValue(key);
+		// 如果从属性文件中获取到的参数值不为 null，则直接返回该值
+		if (value != null) {
+			return value;
+		}
+		// 如果在属性文件中也未获取到参数值，尝试从常量中获取参数值
+		value = ConstantVarService.getValue(key);
+		// 如果从常量中获取到的参数值不为 null，则直接返回该值
+		if (value != null) {
+			return value;
+		}
+		// 如果在以上所有地方都未获取到参数值，抛出运行时异常，提示无法获得参数
+		throw new RuntimeException("无法获得参数:" + key);
+	}
+
+	// 重写 getParameter 方法，用于根据键和用户 ID 获取参数值
+	@Override
+	public String getParameter(String key, String userId) {
+		// 首先尝试从参数服务中获取参数值（根据键和用户 ID）
+		String value = getParameterService().getValue(key, userId);
+		// 如果获取到的参数值不为 null，则直接返回该值
+		if (value != null) {
+			return value;
+		}
+		// 如果在参数服务中未获取到参数值，再尝试从属性文件中获取参数值
+		value = PropertiesFileService.getValue(key);
+		// 如果从属性文件中获取到的参数值不为 null，则直接返回该值
+		if (value != null) {
+			return value;
+		}
+		// 如果在属性文件中也未获取到参数值，尝试从常量中获取参数值
+		value = ConstantVarService.getValue(key);
+		// 如果从常量中获取到的参数值不为 null，则直接返回该值
+		if (value != null) {
+			return value;
+		}
+		// 如果在以上所有地方都未获取到参数值，抛出运行时异常，提示无法获得参数
+		throw new RuntimeException("无法获得参数:" + key);
+	}
+
+	// 重写 getParameterInt 方法，用于根据键获取参数值并转换为整数类型
+	@Override
+	public int getParameterInt(String key) {
+		// 调用 getParameter 方法获取参数值（不传入用户 ID）
+		String val = getParameter(key, null);
+		// 如果获取到的参数值不为空（使用 StringUtils 的 isNotBlank 方法判断）
+		if (StringUtils.isNotBlank(val)) {
+			// 将参数值转换为整数并返回
+			return Integer.valueOf(val);
+		}
+		// 如果获取到的参数值为空，抛出运行时异常，提示参数不存在
+		throw new RuntimeException("the parameter not exist![" + key + "]");
+	}
+
+	// 重写 getParameterBoolean 方法，用于根据键获取参数值并转换为布尔类型
+	@Override
+	public boolean getParameterBoolean(String key) {
+		// 调用 getParameter 方法获取参数值（不传入用户 ID）
+		String val = getParameter(key, null);
+		// 如果获取到的参数值为空（使用 StringUtils 的 isBlank 方法判断）
+		if (StringUtils.isBlank(val)) {
+			// 抛出运行时异常，提示参数不存在
+			throw new RuntimeException("the parameter not exist![" + key + "]");
+		} else {
+			// 如果参数值不为空，将其转换为大写并与 "TRUE" 比较
+			if (val.trim().toUpperCase().equals("TRUE")) {
+				// 如果相等，返回 true
+				return true;
+			} else {
+				// 如果不相等，返回 false
+				return false;
+			}
+		}
+	}

src/wcp-parameter/src/main/java/com/farm/parameter/controller/ApplogController.java

@@ -0,0 +1,315 @@
+package com.farm.parameter.controller;
+
+import java.util.Map;
+
+// 导入javax.annotation包中的Resource注解，用于依赖注入
+import javax.annotation.Resource;
+// 导入javax.servlet.http包中的HttpServletRequest类，用于处理HTTP请求
+import javax.servlet.http.HttpServletRequest;
+// 导入javax.servlet.http包中的HttpSession类，用于管理用户会话
+import javax.servlet.http.HttpSession;
+
+// 导入org.apache.log4j包中的Logger类，用于日志记录
+import org.apache.log4j.Logger;
+// 导入org.springframework.stereotype包中的Controller注解，将该类标记为Spring MVC的控制器
+import org.springframework.stereotype.Controller;
+// 导入org.springframework.web.bind.annotation包中的RequestMapping注解，用于映射HTTP请求到控制器的处理方法
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入org.springframework.web.bind.annotation包中的ResponseBody注解，用于将方法的返回值直接作为HTTP响应体返回
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入org.springframework.web.servlet包中的ModelAndView类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+import com.farm.parameter.service.AloneApplogServiceInter;
+import com.farm.core.page.RequestMode;
+import com.farm.core.page.ViewMode;
+import com.farm.core.sql.query.DBSort;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.web.easyui.EasyUiUtils;
+
+/**
+ * 系统日志
+ *
+ * @author autoCode
+ *
+ */
+// 定义请求映射的基础路径为"/log"
+@RequestMapping("/log")
+// 将该类标记为Spring MVC的控制器
+@Controller
+public class ApplogController
+	// 定义一个静态的Logger对象，用于记录该类的日志信息
+	private final static Logger log = Logger
+			.getLogger(ApplogController.class);
+	// 使用Resource注解进行依赖注入，将AloneApplogServiceInter接口的实现类实例注入到该变量中
+	@Resource
+	AloneApplogServiceInter aloneApplogServiceImpl;
+
+	// 定义获取aloneApplogServiceImpl实例的getter方法
+	public AloneApplogServiceInter getAloneApplogServiceImpl() {
+		return aloneApplogServiceImpl;
+	}
+
+	// 定义设置aloneApplogServiceImpl实例的setter方法
+	public void setAloneApplogServiceImpl(
+			AloneApplogServiceInter aloneApplogServiceImpl) {
+		this.aloneApplogServiceImpl = aloneApplogServiceImpl;
+	}
+	/**
+	 * 进入日志界面
+	 * @param session 用户会话对象
+	 * @return 返回包含视图信息的ModelAndView对象
+	 */
+	// 映射"/log/list"请求到该方法
+	@RequestMapping("/list")
+	public ModelAndView index(HttpSession session) {
+		// 通过ViewMode实例返回一个ModelAndView对象，指定视图名为"parameter/pAloneApplogLayout"
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneApplogLayout");
+	}
+	/**
+	 * 查询结果集合
+	 *
+	 * @param query 数据查询对象
+	 * @param request HTTP请求对象
+	 * @return 返回包含查询结果的Map对象
+	 */
+	// 映射"/log/query"请求到该方法，并将方法返回值直接作为HTTP响应体返回
+	@RequestMapping("/query")
+	@ResponseBody
+	public Map<String, Object> queryall(DataQuery query,
+										HttpServletRequest request) {
+		try {
+			// 使用EasyUiUtils工具类格式化Grid查询参数
+			query = EasyUiUtils.formatGridQuery(request, query);
+			// 初始化数据查询对象，指定查询的SQL语句和要查询的字段
+			query = DataQuery
+					.init(query,
+							"alone_applog a left join alone_auth_user b on b.id=a.APPUSER",
+							"a.id as id,a.CTIME as ctime,a.DESCRIBES as describes,b.name as APPUSER,a.LEVELS as levels,a.METHOD as method,a.CLASSNAME as classname,a.IP as ip");
+			// 为查询添加默认排序规则，按"a.CTIME"字段降序排序
+			query.addDefaultSort(new DBSort("a.CTIME", "DESC"));
+			// 执行查询操作，获取查询结果
+			DataResult result = query.search();
+			// 加载查询结果列表
+			result.LoadListArray();
+			// 对查询结果中的"CTIME"字段进行时间格式化，格式为"yyyy-MM-dd_HH/mm/ss"
+			result.runformatTime("CTIME", "yyyy-MM-dd_HH/mm/ss");
+			// 将查询结果通过EasyUiUtils工具类格式化后，放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance()
+					.putAttrs(EasyUiUtils.formatGridData(result))
+					.returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+	/**
+	 * 显示详细信息（修改或浏览时）
+	 *
+	 * @param pageset 请求模式对象
+	 * @param ids 要操作的实体ID
+	 * @return 返回包含视图信息和模型数据的ModelAndView对象
+	 */
+	// 映射"/log/form"请求到该方法
+	@RequestMapping("/form")
+	public ModelAndView view(RequestMode pageset, String ids) {
+		try {
+			// 根据请求模式的操作类型进行不同处理
+			switch (pageset.getOperateType()) {
+				case (1): { // 新增
+					// 将请求模式对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.returnModelAndView("parameter/pAloneApplogEntity");
+				}
+				case (0): { // 展示
+					// 将请求模式对象和要展示的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", aloneApplogServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneApplogEntity");
+				}
+				case (2): { // 修改
+					// 将请求模式对象和要修改的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", aloneApplogServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneApplogEntity");
+				}
+				default:
+					break;
+			}
+		} catch (Exception e) {
+			// 将异常信息放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+			return ViewMode.getInstance().setError(e + e.getMessage())
+					.returnModelAndView("parameter/pAloneApplogEntity");
+		}
+		// 返回默认视图名的ModelAndView对象
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneParameterEntity");
+	}
+	// /**
+	// * 提交修改数据
+	// *
+	// * @return
+	// */
+	// public String editSubmit() {
+	// try {
+	// entity = aloneIMP.editEntity(entity, getCurrentUser());
+	// pageset = new PageSet(PageType.UPDATE, CommitType.TRUE);
+	// } catch (Exception e) {
+	// pageset = PageSet.initPageSet(pageset, PageType.UPDATE,
+	// CommitType.FALSE, e);
+	// }
+	// return SUCCESS;
+	// }
+	//
+	// /**
+	// * 提交新增数据
+	// *
+	// * @return
+	// */
+	// public String addSubmit() {
+	// try {
+	// entity = aloneIMP.insertEntity(entity, getCurrentUser());
+	// pageset = new PageSet(PageType.ADD, CommitType.TRUE);
+	// } catch (Exception e) {
+	// pageset = PageSet.initPageSet(pageset, PageType.ADD,
+	// CommitType.FALSE, e);
+	// }
+	// return SUCCESS;
+	// }
+	//
+	// /**
+	// * 删除数据
+	// *
+	// * @return
+	// */
+	// public String delSubmit() {
+	// try {
+	// for (String id : parseIds(ids)) {
+	// aloneIMP.deleteEntity(id, getCurrentUser());
+	// }
+	// pageset = new PageSet(PageType.ADD, CommitType.TRUE);
+	// } catch (Exception e) {
+	// pageset = PageSet.initPageSet(pageset, PageType.DEL,
+	// CommitType.FALSE, e);
+	// }
+	// return SUCCESS;
+	// }
+	//
+	// /**
+	// * 跳转
+	// *
+	// * @return
+	// */
+	// public String forSend() {
+	// return SUCCESS;
+	// }
+	//
+	// /**
+	// * 显示详细信息（修改或浏览时）
+	// *
+	// * @return
+	// */
+	// public String view() {
+	// try {
+	// switch (pageset.getPageType()) {
+	// case (1): {// 新增
+	// return SUCCESS;
+	// }
+	// case (0): {// 展示
+	// entity = aloneIMP.getEntity(ids);
+	// return SUCCESS;
+	// }
+	// case (2): {// 修改
+	// entity = aloneIMP.getEntity(ids);
+	// return SUCCESS;
+	// }
+	// default:
+	// break;
+	// }
+	// } catch (Exception e) {
+	// pageset = PageSet.initPageSet(pageset, PageType.OTHER,
+	// CommitType.FALSE, e);
+	// }
+	// return SUCCESS;
+	// }
+	//
+	// private final static AloneApplogManagerInter aloneIMP =
+	// (AloneApplogManagerInter) BEAN("alone_applogProxyId");
+	//
+	// //
+	// ----------------------------------------------------------------------------------
+	// public DataQuery getQuery() {
+	// return query;
+	// }
+	//
+	// public void setQuery(DataQuery query) {
+	// this.query = query;
+	// }
+	//
+	// public DataResult getResult() {
+	// return result;
+	// }
+	//
+	// public void setResult(DataResult result) {
+	// this.result = result;
+	// }
+	//
+	// public AloneApplog getEntity() {
+	// return entity;
+	// }
+	//
+	// public void setEntity(AloneApplog entity) {
+	// this.entity = entity;
+	// }
+	//
+	// public PageSet getPageset() {
+	// return pageset;
+	// }
+	//
+	// public void setPageset(PageSet pageset) {
+	// this.pageset = pageset;
+	// }
+	//
+	// public String getIds() {
+	// return ids;
+	// }
+	//
+	// public void setIds(String ids) {
+	// this.ids = ids;
+	// }
+	//
+	// public InputStream getInputStream() {
+	// return inputStream;
+	// }
+	//
+	// public void setInputStream(InputStream inputStream) {
+	// this.inputStream = inputStream;
+	// }
+	//
+	// public Map<String, Object> getJsonResult() {
+	// return jsonResult;
+	// }
+	//
+	// public void setJsonResult(Map<String, Object> jsonResult) {
+	// this.jsonResult = jsonResult;
+	// }
+	//
+	// private static final Logger log = Logger
+	// .getLogger(ActionAloneApplogQuery.class);
+	// private static final long serialVersionUID = 1L;
+	// /**
+	// * 加载树节点 public String loadTreeNode() { treeNodes =
+	// * EasyUiTreeNode.formatAjaxTree(EasyUiTreeNode .queryTreeNodeOne(id,
+	// * "SORT", "alone_menu", "ID", "PARENTID", "NAME").getResultList(),
+	// * EasyUiTreeNode .queryTreeNodeTow(id, "SORT", "alone_menu", "ID",
+	// * "PARENTID", "NAME").getResultList(), "PARENTID", "ID", "NAME"); return
+	// * SUCCESS; }
+	// *
+	// * @return
+	// */
+}

src/wcp-parameter/src/main/java/com/farm/parameter/controller/DictionaryController.java

@@ -0,0 +1,247 @@
+package com.farm.parameter.controller;
+
+import java.util.Map;
+
+// 导入依赖注入相关注解，用于自动注入依赖的Bean
+import javax.annotation.Resource;
+// 导入处理HTTP请求的类，用于获取请求信息
+import javax.servlet.http.HttpServletRequest;
+// 导入处理HTTP会话的类，用于管理用户会话信息
+import javax.servlet.http.HttpSession;
+
+// 导入日志记录类，用于记录程序运行中的日志信息
+import org.apache.log4j.Logger;
+// 导入Spring MVC的控制器注解，将该类标记为控制器
+import org.springframework.stereotype.Controller;
+// 导入请求映射注解，用于将请求映射到具体的处理方法
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入响应体注解，用于将方法的返回值直接作为HTTP响应体返回
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入模型视图类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+import com.farm.parameter.domain.AloneDictionaryEntity;
+import com.farm.parameter.service.DictionaryEntityServiceInter;
+import com.farm.core.page.OperateType;
+import com.farm.core.page.RequestMode;
+import com.farm.core.page.ViewMode;
+import com.farm.core.sql.query.DBSort;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.web.WebUtils;
+import com.farm.web.easyui.EasyUiUtils;
+
+/**
+ * 数据字典
+ *
+ * @author zhaonaixia
+ * @time 2015-7-06 上午10:19:25
+ *
+ */
+// 定义请求映射的基础路径，所有以/dictionary开头的请求会被该控制器处理
+@RequestMapping("/dictionary")
+// 标记该类为Spring MVC的控制器
+@Controller
+// 继承WebUtils类，可使用其提供的工具方法
+public class DictionaryController extends WebUtils{
+	// 定义日志记录器，用于记录该类的日志信息
+	private static final Logger log = Logger
+			.getLogger(DictionaryController.class);
+
+	// 使用@Resource注解注入DictionaryEntityServiceInter接口的实现类实例
+	@Resource
+	DictionaryEntityServiceInter dictionaryEntityServiceImpl;
+
+	/**
+	 * 查询结果集合
+	 * @param query 数据查询对象，用于封装查询条件和参数
+	 * @param request HTTP请求对象，用于获取请求信息
+	 * @return 返回包含查询结果的Map对象
+	 */
+	// 映射/dictionary/query请求到该方法，并将返回值作为响应体返回
+	@RequestMapping("/query")
+	@ResponseBody
+	public Map<String, Object> queryall(DataQuery query,
+										HttpServletRequest request) {
+		try {
+			// 使用EasyUiUtils工具类格式化Grid查询参数，使其符合EasyUI的格式要求
+			query = EasyUiUtils.formatGridQuery(request, query);
+			// 初始化数据查询对象，指定查询的表和要查询的字段
+			query = DataQuery.init(query, "alone_dictionary_entity",
+					"id,name,entityindex,type,type as types,comments");
+			// 添加默认排序规则，按utime字段降序排序
+			query.addDefaultSort(new DBSort("utime", "DESC"));
+			// 执行查询操作，获取查询结果
+			DataResult result = query.search();
+			// 对查询结果中的TYPE字段进行字典转换，将1转换为序列，0转换为树
+			result.runDictionary("1:序列,0:树", "TYPE");
+			// 将查询结果通过EasyUiUtils工具类格式化后，放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance()
+					.putAttrs(EasyUiUtils.formatGridData(result))
+					.returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 进入数据字典界面
+	 * @param session 用户会话对象，用于获取用户会话信息
+	 * @return 返回包含视图信息的ModelAndView对象
+	 */
+	// 映射/dictionary/list请求到该方法
+	@RequestMapping("/list")
+	public ModelAndView index(HttpSession session) {
+		// 通过ViewMode实例返回一个ModelAndView对象，指定视图名为parameter/pAloneDictionaryEntityLayout
+		return ViewMode.getInstance()
+				.returnModelAndView("parameter/pAloneDictionaryEntityLayout");
+	}
+
+	/**
+	 * 提交修改数据
+	 * @param dictionary 要修改的字典实体对象
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 返回包含操作结果的Map对象
+	 */
+	// 映射/dictionary/edit请求到该方法，并将返回值作为响应体返回
+	@RequestMapping("/edit")
+	@ResponseBody
+	public Map<String, Object> editSubmit(AloneDictionaryEntity dictionary, HttpSession session) {
+		try {
+			// 调用服务层的editEntity方法修改字典实体，并传入当前用户信息
+			AloneDictionaryEntity entity = dictionaryEntityServiceImpl.editEntity(dictionary, getCurrentUser(session));
+			// 将修改后的实体对象放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance().putAttr("entity", entity)
+					.returnObjMode();
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 提交新增数据
+	 * @param dictionary 要新增的字典实体对象
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 返回包含操作结果的Map对象
+	 */
+	// 映射/dictionary/add请求到该方法，并将返回值作为响应体返回
+	@RequestMapping("/add")
+	@ResponseBody
+	public Map<String, Object> addSubmit(AloneDictionaryEntity dictionary, HttpSession session) {
+		try {
+			// 调用服务层的insertEntity方法插入字典实体，并传入当前用户信息
+			AloneDictionaryEntity entity = dictionaryEntityServiceImpl.insertEntity(dictionary,
+					getCurrentUser(session));
+			// 设置操作类型为新增，将新增的实体对象放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance().setOperate(OperateType.ADD)
+					.putAttr("entity", entity).returnObjMode();
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 删除数据
+	 * @param ids 要删除的记录的ID集合，多个ID用逗号分隔
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 返回包含操作结果的Map对象
+	 */
+	// 映射/dictionary/del请求到该方法，并将返回值作为响应体返回
+	@RequestMapping("/del")
+	@ResponseBody
+	public Map<String, Object> delSubmit(String ids, HttpSession session) {
+		try {
+			// 解析ID集合，将其拆分为单个ID
+			for (String id : parseIds(ids)) {
+				// 调用服务层的deleteEntity方法删除指定ID的字典实体，并传入当前用户信息
+				dictionaryEntityServiceImpl.deleteEntity(id, getCurrentUser(session));
+			}
+			// 返回一个空的操作结果Map对象
+			return ViewMode.getInstance().returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 显示详细信息（修改或浏览时）
+	 * @param pageset 请求模式对象，包含操作类型等信息
+	 * @param ids 要操作的记录的ID
+	 * @return 返回包含视图信息和模型数据的ModelAndView对象
+	 */
+	// 映射/dictionary/form请求到该方法
+	@RequestMapping("/form")
+	public ModelAndView view(RequestMode pageset, String ids) {
+		try {
+			// 根据请求模式的操作类型进行不同处理
+			switch (pageset.getOperateType()) {
+				case (1): { // 新增
+					// 将请求模式对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.returnModelAndView("parameter/pAloneDictionaryEntityEntity");
+				}
+				case (0): { // 展示
+					// 将请求模式对象和要展示的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", dictionaryEntityServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneDictionaryEntityEntity");
+				}
+				case (2): { // 修改
+					// 将请求模式对象、要修改的实体对象和ID放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", dictionaryEntityServiceImpl.getEntity(ids))
+							.putAttr("ids", ids)
+							.returnModelAndView("parameter/pAloneDictionaryEntityEntity");
+				}
+				default:
+					break;
+			}
+		} catch (Exception e) {
+			// 将异常信息放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+			return ViewMode.getInstance().setError(e + e.getMessage())
+					.returnModelAndView("parameter/pAloneDictionaryEntityEntity");
+		}
+		// 返回默认视图名的ModelAndView对象
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneDictionaryEntityEntity");
+	}
+
+	/**
+	 * 验证key是否重复
+	 * @param key 要验证的key值
+	 * @param ids 当前记录的ID，用于排除自身
+	 * @return 返回包含验证结果的Map对象
+	 */
+	// 映射/dictionary/ALONEDictionary_validateIsRepeatKey请求到该方法，并将返回值作为响应体返回
+	@RequestMapping("/ALONEDictionary_validateIsRepeatKey")
+	@ResponseBody
+	public Map<String, Object> validateIsRepeatKey(String key,String ids) {
+		// 调用服务层的validateIsRepeatKey方法验证key是否重复
+		boolean  isRepeatKey = dictionaryEntityServiceImpl.validateIsRepeatKey(key, ids);
+		// 将验证结果放入ViewMode实例中，并返回包含结果的Map对象
+		return ViewMode.getInstance()
+				.putAttr("isRepeatKey", isRepeatKey)
+				.returnObjMode();
+	}
+
+}

src/wcp-parameter/src/main/java/com/farm/parameter/controller/DictionaryTypeController.java

@@ -0,0 +1,397 @@
+package com.farm.parameter.controller;
+
+import java.util.Map;
+
+// 用于依赖注入，将Spring容器中的Bean注入到当前类的属性中
+import javax.annotation.Resource;
+// 用于处理HTTP请求，获取请求参数、请求头等信息
+import javax.servlet.http.HttpServletRequest;
+// 用于管理用户会话，存储和获取会话相关的数据
+import javax.servlet.http.HttpSession;
+
+// 用于记录日志信息，方便调试和监控程序运行状态
+import org.apache.log4j.Logger;
+// 标记该类为Spring MVC的控制器，用于处理HTTP请求
+import org.springframework.stereotype.Controller;
+// 用于将HTTP请求映射到控制器的方法上
+import org.springframework.web.bind.annotation.RequestMapping;
+// 用于将方法的返回值直接作为HTTP响应体返回
+import org.springframework.web.bind.annotation.ResponseBody;
+// 用于封装模型数据和视图信息，返回给前端页面
+import org.springframework.web.servlet.ModelAndView;
+
+import com.farm.parameter.domain.AloneDictionaryType;
+import com.farm.parameter.service.DictionaryTypeServiceInter;
+import com.farm.core.page.OperateType;
+import com.farm.core.page.RequestMode;
+import com.farm.core.page.ViewMode;
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DBSort;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.web.WebUtils;
+import com.farm.web.easyui.EasyUiTreeNode;
+import com.farm.web.easyui.EasyUiUtils;
+
+/**
+ * 字典类型
+ *
+ * @author zhaonaixia
+ * @time 2015-7-06 上午10:19:25
+ *
+ */
+// 所有以 /dictionaryType 开头的请求都会由该控制器处理
+@RequestMapping("/dictionaryType")
+// 标记该类为Spring MVC的控制器
+@Controller
+// 继承WebUtils类，可使用其提供的工具方法
+public class DictionaryTypeController extends WebUtils {
+	// 父组织机构名称
+	private String parentName;
+	// 记录该类的日志信息
+	private static final Logger log = Logger
+			.getLogger(DictionaryTypeController.class);
+
+	// 注入DictionaryTypeServiceInter接口的实现类实例
+	@Resource
+	DictionaryTypeServiceInter dictionaryTypeServiceImpl;
+
+	/**
+	 * 查询结果集合
+	 *
+	 * @param query 数据查询对象，用于封装查询条件和排序规则
+	 * @param request HTTP请求对象，用于获取请求参数
+	 * @param ids 可选的查询条件参数
+	 * @return 包含查询结果的Map对象
+	 */
+	// 处理 /dictionaryType/query 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/query")
+	@ResponseBody
+	public Map<String, Object> queryall(DataQuery query,
+										HttpServletRequest request, String ids) {
+		try {
+			// 使用EasyUiUtils工具类格式化Grid查询参数
+			query = EasyUiUtils.formatGridQuery(request, query);
+			// 初始化数据查询对象，设置查询的表和要查询的字段
+			query = DataQuery
+					.init(
+							query,
+							"alone_dictionary_type a LEFT JOIN alone_dictionary_type b ON a.parentid = b.id",
+							"a.id AS ID,a.sort AS SORT,a.name AS NAME,a.entitytype AS ENTITYTYPE,a.state AS STATE,b.name AS PNAME");
+			// 添加SQL规则，只查询状态为0或1的记录（非删除的组织机构）
+			query.addSqlRule(" and (a.state = '0' or a.state = '1') ");
+			// 添加默认排序规则，按 a.sort 字段升序排序
+			query.addDefaultSort(new DBSort("a.sort", "asc"));
+			// 如果ids参数不为空，则添加查询规则，只查询 a.entity 等于 ids 的记录
+			if (ids != null && ids.trim().length() > 0) {
+				query.addRule(new DBRule("a.entity", ids, "="));
+			}
+			// 执行查询操作，获取查询结果
+			DataResult result = query.search();
+			// 对查询结果中的 STATE 字段进行字典转换，将 1 转换为可用，0 转换为禁用
+			result.runDictionary("1:可用,0:禁用", "STATE");
+			// 将查询结果通过EasyUiUtils工具类格式化后，放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance()
+					.putAttrs(EasyUiUtils.formatGridData(result))
+					.returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 提交修改数据
+	 *
+	 * @param dictionary 要修改的字典类型实体对象
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 包含修改后实体对象的Map对象
+	 */
+	// 处理 /dictionaryType/edit 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/edit")
+	@ResponseBody
+	public Map<String, Object>  editSubmit(AloneDictionaryType dictionary, HttpSession session) {
+		try {
+			// 调用服务层的 editEntity 方法修改字典类型实体，并传入当前用户信息
+			AloneDictionaryType entity = dictionaryTypeServiceImpl.editEntity(dictionary, getCurrentUser(session));
+			// 将修改后的实体对象放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance().putAttr("entity", entity)
+					.returnObjMode();
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 提交新增数据
+	 *
+	 * @param dictionary 要新增的字典类型实体对象
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 包含新增后实体对象的Map对象
+	 */
+	// 处理 /dictionaryType/add 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/add")
+	@ResponseBody
+	public Map<String, Object> addSubmit(AloneDictionaryType dictionary, HttpSession session) {
+		try {
+			// 调用服务层的 insertEntity 方法插入字典类型实体，并传入当前用户信息
+			AloneDictionaryType entity = dictionaryTypeServiceImpl.insertEntity(dictionary, getCurrentUser(session));
+			// 设置操作类型为新增，将新增的实体对象放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance().setOperate(OperateType.ADD)
+					.putAttr("entity", entity).returnObjMode();
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 删除数据
+	 *
+	 * @param ids 要删除的记录的ID集合，多个ID用逗号分隔
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 操作结果的Map对象
+	 */
+	// 处理 /dictionaryType/del 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/del")
+	@ResponseBody
+	public Map<String, Object> delSubmit(String ids, HttpSession session) {
+		try {
+			// 解析ID集合，将其拆分为单个ID
+			for (String id : parseIds(ids)) {
+				// 如果要删除的实体存在，则调用服务层的 deleteEntity 方法删除该实体，并传入当前用户信息
+				if (dictionaryTypeServiceImpl.getEntity(id) != null) {
+					dictionaryTypeServiceImpl.deleteEntity(id, getCurrentUser(session));
+				}
+			}
+			// 返回一个空的操作结果Map对象
+			return ViewMode.getInstance().returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 跳转
+	 *
+	 * @param ids 可选的参数
+	 * @param type 跳转类型，0 表示树，其他表示序列
+	 * @return 包含视图信息和参数的ModelAndView对象
+	 */
+	// 处理 /dictionaryType/ALONEDictionaryType_ACTION_CONSOLE 请求
+	@RequestMapping("/ALONEDictionaryType_ACTION_CONSOLE")
+	public ModelAndView forSend(String ids, String type) {
+		if ("0".equals(type)) { // 如果 type 为 0，则跳转到树布局页面
+			return ViewMode.getInstance()
+					.putAttr("ids", ids)
+					.putAttr("type", type)
+					.returnModelAndView("parameter/pAloneDictionaryTypeTreeLayout");
+		} else { // 否则跳转到序列布局页面
+			return ViewMode.getInstance()
+					.putAttr("ids", ids)
+					.putAttr("type", type)
+					.returnModelAndView("parameter/pAloneDictionaryTypeLayout");
+		}
+	}
+
+	/**
+	 * 显示详细信息（修改或浏览时）
+	 *
+	 * @param pageset 请求模式对象，包含操作类型等信息
+	 * @param ids 要操作的记录的ID
+	 * @param dicId 关联的数据字典ID
+	 * @return 包含视图信息和模型数据的ModelAndView对象
+	 */
+	// 处理 /dictionaryType/form 请求
+	@RequestMapping("/form")
+	public ModelAndView view(RequestMode pageset, String ids, String dicId) {
+		try {
+			// 根据请求模式的操作类型进行不同处理
+			switch (pageset.getOperateType()) {
+				case (1): { // 新增
+					// 如果 dicId 为空，则抛出异常
+					if (dicId == null || dicId.equals("")) {
+						throw new RuntimeException("找不到关联的数据字典！");
+					}
+					// 创建一个新的字典类型实体对象，并设置其 entity 属性为 dicId
+					AloneDictionaryType entity = new AloneDictionaryType();
+					entity.setEntity(dicId);
+					// 将请求模式对象和实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", entity)
+							.returnModelAndView("parameter/pAloneDictionaryTypeEntity");
+				}
+				case (0): { // 展示
+					// 将请求模式对象和要展示的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", dictionaryTypeServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneDictionaryTypeEntity");
+				}
+				case (2): { // 修改
+					// 将请求模式对象和要修改的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", dictionaryTypeServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneDictionaryTypeEntity");
+				}
+				default:
+					break;
+			}
+		} catch (Exception e) {
+			// 将异常信息放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+			return ViewMode.getInstance().setError(e + e.getMessage())
+					.returnModelAndView("parameter/pAloneDictionaryEntityEntity");
+		}
+		// 返回默认视图名的ModelAndView对象
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneDictionaryEntityEntity");
+	}
+
+	/**
+	 * (树组织结构)显示详细信息
+	 *
+	 * @param pageset 请求模式对象，包含操作类型等信息
+	 * @param ids 要操作的记录的ID
+	 * @param dicId 关联的数据字典ID
+	 * @param parentId 父节点ID
+	 * @return 包含视图信息和模型数据的ModelAndView对象
+	 */
+	// 处理 /dictionaryType/viewTreeform 请求
+	@RequestMapping("/viewTreeform")
+	public ModelAndView viewTree(RequestMode pageset, String ids, String dicId, String parentId) {
+		try {
+			// 根据请求模式的操作类型进行不同处理
+			switch (pageset.getOperateType()) {
+				case (1): { // 新增
+					// 如果 dicId 为空，则抛出异常
+					if (dicId == null || dicId.equals("")) {
+						throw new RuntimeException("找不到关联的数据字典！");
+					}
+					// 创建一个新的字典类型实体对象，并设置其 entity 属性为 dicId
+					AloneDictionaryType entity = new AloneDictionaryType();
+					entity.setEntity(dicId);
+					// 如果父节点ID不为空，则获取父节点实体对象
+					if (parentId != null && !parentId.equals("")) {
+						AloneDictionaryType pEntity = dictionaryTypeServiceImpl.getEntity(parentId);
+						// 如果父节点状态为可用，则设置父节点名称和父节点ID
+						if (pEntity.getState().equals("1")) {
+							parentName = pEntity.getName(); // 回显父组织机构名称
+							entity.setParentid(parentId);
+						}
+					} else {
+						// 否则设置父节点ID为 NONE
+						entity.setParentid("NONE");
+					}
+					// 将请求模式对象、实体对象和父节点名称放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", entity)
+							.putAttr("parentName", parentName)
+							.returnModelAndView("parameter/pAloneDictionaryTypeTreeEntity");
+				}
+				case (0): { // 展示
+					// 将请求模式对象和要展示的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", dictionaryTypeServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneDictionaryTypeTreeEntity");
+				}
+				case (2): { // 修改
+					// 获取要修改的实体对象
+					AloneDictionaryType entity = dictionaryTypeServiceImpl.getEntity(ids);
+					// 如果父节点ID不为 NONE，则获取父节点名称
+					if (!entity.getParentid().equals("NONE")) {
+						parentName = dictionaryTypeServiceImpl.getEntity(entity.getParentid())
+								.getName();
+					}
+					// 将请求模式对象、实体对象和父节点名称放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", entity)
+							.putAttr("parentName", parentName)
+							.returnModelAndView("parameter/pAloneDictionaryTypeTreeEntity");
+				}
+				default:
+					break;
+			}
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+			return ViewMode.getInstance().setError(e + e.getMessage())
+					.returnModelAndView("parameter/pAloneDictionaryTypeTreeEntity");
+		}
+		// 返回默认视图名的ModelAndView对象
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneDictionaryTypeTreeEntity");
+	}
+
+	/**
+	 * 加载树节点
+	 *
+	 * @param ids 关联的数据字典ID
+	 * @param id 当前节点ID
+	 * @return 格式化后的树节点数据
+	 */
+	// 处理 /dictionaryType/dictionaryTreeNote 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/dictionaryTreeNote")
+	@ResponseBody
+	public Object loadTreeNode(String ids, String id) {
+		// 如果当前节点ID为空，则设置为 NONE
+		if (id == null) {
+			id = "NONE";
+		}
+		try {
+			// 格式化异步Ajax树节点数据，查询一级和二级树节点，并进行格式化返回
+			return EasyUiTreeNode
+					.formatAsyncAjaxTree(
+							EasyUiTreeNode
+									.queryTreeNodeOne(
+											id,
+											"SORT",
+											" (SELECT a.id AS ID,a.parentid AS PARENTID,a.name AS NAME,a.ctime AS CTIME,a.sort AS SORT,a.entity AS ENTITY,a.state AS STATE FROM ALONE_DICTIONARY_TYPE a LEFT JOIN ALONE_DICTIONARY_ENTITY b ON a.ENTITY = b.id  WHERE b.type = 0) ",
+											"ID",
+											"PARENTID",
+											"NAME",
+											"CTIME",
+											" and a.ENTITY='" + ids
+													+ "' and a.state!=2")
+									.getResultList(),
+							EasyUiTreeNode
+									.queryTreeNodeTow(
+											id,
+											"SORT",
+											" (SELECT a.id AS ID,a.parentid AS PARENTID,a.name AS NAME,a.ctime AS CTIME,a.sort AS SORT,a.entity AS ENTITY,a.state AS STATE FROM ALONE_DICTIONARY_TYPE a LEFT JOIN ALONE_DICTIONARY_ENTITY b ON a.ENTITY = b.id  WHERE b.type = 0) ",
+											"ID",
+											"PARENTID",
+											"NAME",
+											"CTIME",
+											" and a.ENTITY='" + ids
+													+ "' and a.state!=2")
+									.getResultList(), "PARENTID", "ID", "NAME",
+							"CTIME");
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/controller/ParameterController.java

@@ -0,0 +1,411 @@
+// 声明当前类所在的包
+package com.farm.parameter.controller;
+
+// 导入用于创建动态数组的类
+import java.util.ArrayList;
+// 导入用于创建键值对映射的类
+import java.util.HashMap;
+// 导入用于处理列表的接口
+import java.util.List;
+// 导入用于处理键值对映射的接口
+import java.util.Map;
+// 导入用于遍历Map的条目接口
+import java.util.Map.Entry;
+
+// 用于依赖注入，将Spring容器中的Bean注入到当前类的属性中
+import javax.annotation.Resource;
+// 用于处理HTTP请求，获取请求参数、请求头等信息
+import javax.servlet.http.HttpServletRequest;
+// 用于管理用户会话，存储和获取会话相关的数据
+import javax.servlet.http.HttpSession;
+
+// 用于记录日志信息，方便调试和监控程序运行状态
+import org.apache.log4j.Logger;
+// 标记该类为Spring MVC的控制器，用于处理HTTP请求
+import org.springframework.stereotype.Controller;
+// 用于将HTTP请求映射到控制器的方法上
+import org.springframework.web.bind.annotation.RequestMapping;
+// 用于将方法的返回值直接作为HTTP响应体返回
+import org.springframework.web.bind.annotation.ResponseBody;
+// 用于封装模型数据和视图信息，返回给前端页面
+import org.springframework.web.servlet.ModelAndView;
+
+import com.farm.parameter.domain.AloneParameter;
+import com.farm.parameter.service.ParameterServiceInter;
+import com.farm.parameter.service.impl.ConstantVarService;
+import com.farm.parameter.service.impl.PropertiesFileService;
+import com.farm.core.page.RequestMode;
+import com.farm.core.page.ViewMode;
+import com.farm.core.sql.query.DBSort;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.web.WebUtils;
+import com.farm.web.easyui.EasyUiUtils;
+
+/**
+ * 系统参数Action
+ *
+ * @author zhang_hc
+ * @time 2012-8-31 上午11:47:25
+ * @author wangdong
+ * @time 2015-7-03 上午10:19:25
+ */
+// 所有以 /parameter 开头的请求都会由该控制器处理
+@RequestMapping("/parameter")
+// 标记该类为Spring MVC的控制器
+@Controller
+// 继承WebUtils类，可使用其提供的工具方法
+public class ParameterController extends WebUtils {
+
+	// 定义日志记录器，用于记录该类的日志信息
+	private static final Logger log = Logger
+			.getLogger(ParameterController.class);
+
+	// 使用@Resource注解注入ParameterServiceInter接口的实现类实例
+	@Resource
+	ParameterServiceInter parameterServiceImpl;
+
+	/**
+	 * 查询结果集合
+	 *
+	 * @param query 数据查询对象，用于封装查询条件和排序规则
+	 * @param request HTTP请求对象，用于获取请求参数
+	 * @return 包含查询结果的Map对象
+	 */
+	// 处理 /parameter/query 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/query")
+	@ResponseBody
+	public Map<String, Object> queryall(DataQuery query,
+										HttpServletRequest request) {
+		// 使用EasyUiUtils工具类格式化Grid查询参数
+		query = EasyUiUtils.formatGridQuery(request, query);
+		try {
+			// 初始化数据查询对象，设置查询的表和要查询的字段
+			query = DataQuery.init(//
+					query, //
+					"Alone_Parameter a", //
+					"id,domain,name,pkey,pvalue,vtype,comments");
+
+			// 添加排序规则，按最后修改时间降序排序
+			query.addSort(new DBSort("a.utime", "desc"));
+			// 执行查询操作，获取查询结果
+			DataResult result = query.search();
+			// 创建一个HashMap用于状态转义
+			HashMap<String, String> transMap = new HashMap<String, String>();
+			// 将 null 转义为空字符串
+			transMap.put("null", "");
+			// 对查询结果中的 COMMENTS 字段进行状态转义
+			result.runDictionary(transMap, "COMMENTS");
+			// 将查询结果通过EasyUiUtils工具类格式化后，放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance()
+					.putAttrs(EasyUiUtils.formatGridData(result))
+					.returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 进入参数定义界面
+	 *
+	 * @param session 用户会话对象，用于获取用户会话信息
+	 * @return 返回包含视图信息的ModelAndView对象
+	 */
+	// 处理 /parameter/list 请求
+	@RequestMapping("/list")
+	public ModelAndView index(HttpSession session) {
+		// 通过ViewMode实例返回一个ModelAndView对象，指定视图名为 parameter/pAloneParameterLayout
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneParameterLayout");
+	}
+
+	/**
+	 * 进入参数配置界面
+	 *
+	 * @return 返回包含视图信息和模型数据的ModelAndView对象
+	 */
+	// 处理 /parameter/editlist 请求
+	@RequestMapping("/editlist")
+	public ModelAndView showPara() {
+		// 从PropertiesFileService中获取文件属性条目列表
+		List<Entry<String, String>> filePropertys = PropertiesFileService
+				.getEntrys();
+		// 从ConstantVarService中获取常量属性条目列表
+		List<Entry<String, String>> constantPropertys = ConstantVarService
+				.getEntrys();
+		// 将文件属性条目列表和常量属性条目列表放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+		return ViewMode.getInstance().putAttr("filePropertys", filePropertys)
+				.putAttr("constantPropertys", constantPropertys)
+				.returnModelAndView("parameter/pAloneParameterConf");
+	}
+
+	// 处理 /parameter/userelist 请求
+	@RequestMapping("/userelist")
+	public ModelAndView showUserPara() {
+		// 通过ViewMode实例返回一个ModelAndView对象，指定视图名为 parameter/pAloneParameterConfForUser
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneParameterConfForUser");
+	}
+
+	/**
+	 * 查询数据并格式化为EasyUI所需的列表
+	 *
+	 * @param query 数据查询对象，用于封装查询条件和排序规则
+	 * @param request HTTP请求对象，用于获取请求参数
+	 * @return 格式化后的参数列表
+	 */
+	// 处理 /parameter/queryForEU 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/queryForEU")
+	@ResponseBody
+	public List<Map<String, Object>> queryallForEasyUi(DataQuery query,
+													   HttpServletRequest request) {
+		try {
+			// 调用parameterServiceImpl的getAllParameters方法获取所有参数，并使用EasyUiUtils工具类将其格式化为PropertyGrid所需的数据格式
+			List<Map<String, Object>> propertys = EasyUiUtils
+					.formatPropertygridData(
+							parameterServiceImpl.getAllParameters(), "NAME",
+							"PVALUE", "DOMAIN", "VTYPE", "RULES", "ID");
+			return propertys;
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e);
+			// 返回一个空的列表
+			return new ArrayList<Map<String, Object>>();
+		}
+	}
+
+	/**
+	 * 查询用户参数并格式化为EasyUI所需的列表
+	 *
+	 * @param query 数据查询对象，用于封装查询条件和排序规则
+	 * @param request HTTP请求对象，用于获取请求参数
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 格式化后的用户参数列表
+	 */
+	// 处理 /parameter/userqueryForEU 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/userqueryForEU")
+	@ResponseBody
+	public List<Map<String, Object>> userQueryallForEasyUi(DataQuery query,
+														   HttpServletRequest request, HttpSession session) {
+		try {
+			// 调用parameterServiceImpl的getUserParameters方法获取当前用户的参数，并使用EasyUiUtils工具类将其格式化为PropertyGrid所需的数据格式
+			List<Map<String, Object>> propertys = EasyUiUtils
+					.formatPropertygridData(
+							parameterServiceImpl
+									.getUserParameters(getCurrentUser(session)
+											.getId()), "NAME", "PVALUE",
+							"DOMAIN", "VTYPE", "RULES", "ID");
+			return propertys;
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e);
+			// 返回一个空的列表
+			return new ArrayList<Map<String, Object>>();
+		}
+	}
+
+	/**
+	 * 提交修改数据
+	 *
+	 * @param entity 要修改的系统参数实体对象
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 包含修改后实体对象的Map对象
+	 */
+	// 处理 /parameter/edit 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/edit")
+	@ResponseBody
+	public Map<String, Object> editSubmit(AloneParameter entity,
+										  HttpSession session) {
+		try {
+			// 调用parameterServiceImpl的editEntity方法修改系统参数实体，并传入当前用户信息
+			entity = parameterServiceImpl.editEntity(entity,
+					getCurrentUser(session));
+			// 将修改后的实体对象放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance().putAttr("entity", entity)
+					.returnObjMode();
+		} catch (Exception e) {
+			// 打印异常堆栈信息
+			e.printStackTrace();
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 提交新增数据
+	 *
+	 * @param entity 要新增的系统参数实体对象
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 包含新增后实体对象的Map对象
+	 */
+	// 处理 /parameter/add 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/add")
+	@ResponseBody
+	public Map<String, Object> addSubmit(AloneParameter entity,
+										 HttpSession session) {
+		try {
+			// 调用parameterServiceImpl的insertEntity方法插入系统参数实体，并传入实体对象、域和当前用户信息
+			entity = parameterServiceImpl.insertEntity(entity,
+					entity.getDomain(), getCurrentUser(session));
+			// 将新增后的实体对象放入ViewMode实例中，并返回包含结果的Map对象
+			return ViewMode.getInstance().putAttr("entity", entity)
+					.returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 删除数据
+	 *
+	 * @param ids 要删除的记录的ID集合，多个ID用逗号分隔
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 操作结果的Map对象
+	 */
+	// 处理 /parameter/del 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/del")
+	@ResponseBody
+	public Map<String, Object> delSubmit(String ids, HttpSession session) {
+		try {
+			// 解析ID集合，将其拆分为单个ID
+			for (String id : parseIds(ids)) {
+				// 调用parameterServiceImpl的deleteEntity方法删除指定ID的系统参数实体，并传入当前用户信息
+				parameterServiceImpl.deleteEntity(id, getCurrentUser(session));
+			}
+			// 返回一个空的操作结果Map对象
+			return ViewMode.getInstance().returnObjMode();
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e.getMessage());
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+	}
+
+	/**
+	 * 修改系统参数的值
+	 *
+	 * @param ids 包含参数ID和新值的字符串，多个参数用 &2582& 分隔，ID和值用 &2581& 分隔
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 操作结果的Map对象
+	 */
+	// 处理 /parameter/editEU 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/editEU")
+	@ResponseBody
+	public Map<String, Object> editSubmitByPValue(String ids,
+												  HttpSession session) {
+		try {
+			// 将传入的ids字符串按 &2582& 分割成参数数组
+			String[] paraArrays = ids.split("&2582&");
+			for (int i = 0; i < paraArrays.length; i++) {
+				// 将每个参数按 &2581& 分割成ID和值
+				String[] paraEntry = paraArrays[i].split("&2581&");
+				String id = paraEntry[0];
+				String value = paraEntry[1];
+				// 调用parameterServiceImpl的setValue方法修改系统参数的值，并传入参数键、新值和当前用户信息
+				parameterServiceImpl.setValue(parameterServiceImpl
+								.getEntity(id).getPkey(), value,
+						getCurrentUser(session));
+			}
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e);
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+		// 返回一个空的操作结果Map对象
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 修改用户系统参数的值
+	 *
+	 * @param ids 包含参数ID和新值的字符串，多个参数用 &2582& 分隔，ID和值用 &2581& 分隔
+	 * @param session 用户会话对象，用于获取当前用户信息
+	 * @return 操作结果的Map对象
+	 */
+	// 处理 /parameter/editUserEU 请求，并将返回值作为JSON响应返回
+	@RequestMapping("/editUserEU")
+	@ResponseBody
+	public Map<String, Object> editSubmitByUserPValue(String ids,
+													  HttpSession session) {
+		try {
+			// 将传入的ids字符串按 &2582& 分割成参数数组
+			String[] paraArrays = ids.split("&2582&");
+			for (int i = 0; i < paraArrays.length; i++) {
+				// 将每个参数按 &2581& 分割成ID和值
+				String[] paraEntry = paraArrays[i].split("&2581&");
+				String id = paraEntry[0];
+				String value = paraEntry[1];
+				// 调用parameterServiceImpl的setUserValue方法修改用户系统参数的值，并传入参数键、新值和当前用户信息
+				parameterServiceImpl.setUserValue(parameterServiceImpl
+								.getEntity(id).getPkey(), value,
+						getCurrentUser(session));
+			}
+		} catch (Exception e) {
+			// 记录异常信息到日志
+			log.error(e);
+			// 将异常信息放入ViewMode实例中，并返回包含错误信息的Map对象
+			return ViewMode.getInstance().setError(e.getMessage())
+					.returnObjMode();
+		}
+		// 返回一个空的操作结果Map对象
+		return ViewMode.getInstance().returnObjMode();
+	}
+
+	/**
+	 * 显示详细信息（修改或浏览时）
+	 *
+	 * @param pageset 请求模式对象，包含操作类型等信息
+	 * @param ids 要操作的记录的ID
+	 * @return 包含视图信息和模型数据的ModelAndView对象
+	 */
+	// 处理 /parameter/form 请求
+	@RequestMapping("/form")
+	public ModelAndView view(RequestMode pageset, String ids) {
+		try {
+			// 根据请求模式的操作类型进行不同处理
+			switch (pageset.getOperateType()) {
+				case (1): { // 新增
+					// 将请求模式对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.returnModelAndView("parameter/pAloneParameterEntity");
+				}
+				case (0): { // 展示
+					// 将请求模式对象和要展示的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", parameterServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneParameterEntity");
+				}
+				case (2): { // 修改
+					// 将请求模式对象和要修改的实体对象放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+					return ViewMode.getInstance().putAttr("pageset", pageset)
+							.putAttr("entity", parameterServiceImpl.getEntity(ids))
+							.returnModelAndView("parameter/pAloneParameterEntity");
+				}
+				default:
+					break;
+			}
+		} catch (Exception e) {
+			// 将异常信息放入ViewMode实例中，并返回指定视图名的ModelAndView对象
+			return ViewMode.getInstance().setError(e + e.getMessage())
+					.returnModelAndView("parameter/pAloneParameterEntity");
+		}
+		// 返回默认视图名的ModelAndView对象
+		return ViewMode.getInstance().returnModelAndView(
+				"parameter/pAloneParameterEntity");
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/AloneApplogDaoInter.java

@@ -0,0 +1,71 @@
+package com.farm.parameter.dao;
+
+import org.hibernate.Session;
+
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.parameter.domain.AloneApplog;
+
+import java.util.List;
+import java.util.Map;
+
+/**系统日志
+ * @author MAC_wd
+ *
+ */
+public interface AloneApplogDaoInter  {
+	/** 删除一个实体
+ 	 * @param entity 实体
+ 	 */
+ 	public void deleteEntity(AloneApplog entity) ;
+	/** 由id获得一个实体
+	 * @param id
+	 * @return
+	 */
+	public AloneApplog getEntity(String id) ;
+	/** 插入一条数据
+	 * @param entity
+	 */
+	public AloneApplog insertEntity(AloneApplog entity);
+	/** 获得记录数量
+	 * @return
+	 */
+	public int getAllListNum();
+	/**修改一个记录
+	 * @param entity
+	 */
+	public void editEntity(AloneApplog entity);
+	/**获得一个session
+	 */
+	public Session getSession();
+	/**执行一条查询语句
+	 */
+	public DataResult runSqlQuery(DataQuery query);
+	/**
+	 * 条件删除实体，依据对象字段值(一般不建议使用该方法)
+	 * 
+	 * @param rules
+	 *            删除条件
+	 */
+	public void deleteEntitys(List<DBRule> rules);
+
+	/**
+	 * 条件查询实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+	 * 
+	 * @param rules
+	 *            查询条件
+	 * @return
+	 */
+	public List<AloneApplog> selectEntitys(List<DBRule> rules);
+
+	/**
+	 * 条件修改实体，依据对象字段值(一般不建议使用该方法)
+	 * 
+	 * @param values
+	 *            被修改的键值对
+	 * @param rules
+	 *            修改条件
+	 */
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules);
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/AloneparameterlocalDaoInter.java

@@ -0,0 +1,112 @@
+package com.farm.parameter.dao;
+
+import com.farm.parameter.domain.Aloneparameterlocal;
+import org.hibernate.Session;
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import java.util.List;
+import java.util.Map;
+
+/* *
+ *功能：用户个性化参数数据库持久层接口
+ *详细：
+ *
+ *版本：v0.1
+ *作者：Farm代码工程自动生成
+ *日期：20141204174206
+ *说明：
+ */
+public interface AloneparameterlocalDaoInter {
+	/**
+	 * 删除一个用户个性化参数实体
+	 * 
+	 * @param entity
+	 *            实体
+	 */
+	public void deleteEntity(Aloneparameterlocal aloneparameterlocal);
+
+	/**
+	 * 由用户个性化参数id获得一个用户个性化参数实体
+	 * 
+	 * @param id
+	 * @return
+	 */
+	public Aloneparameterlocal getEntity(String aloneparameterlocalid);
+
+	/**
+	 * 插入一条用户个性化参数数据
+	 * 
+	 * @param entity
+	 */
+	public Aloneparameterlocal insertEntity(
+			Aloneparameterlocal aloneparameterlocal);
+
+	/**
+	 * 获得记录数量
+	 * 
+	 * @return
+	 */
+	public int getAllListNum();
+
+	/**
+	 * 修改一个用户个性化参数记录
+	 * 
+	 * @param entity
+	 */
+	public void editEntity(Aloneparameterlocal aloneparameterlocal);
+
+	/**
+	 * 获得一个session
+	 */
+	public Session getSession();
+
+	/**
+	 * 执行一条用户个性化参数查询语句
+	 */
+	public DataResult runSqlQuery(DataQuery query);
+
+	/**
+	 * 条件删除用户个性化参数实体，依据对象字段值(一般不建议使用该方法)
+	 * 
+	 * @param rules
+	 *            删除条件
+	 */
+	public void deleteEntitys(List<DBRule> rules);
+
+	/**
+	 * 条件查询用户个性化参数实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+	 * 
+	 * @param rules
+	 *            查询条件
+	 * @return
+	 */
+	public List<Aloneparameterlocal> selectEntitys(List<DBRule> rules);
+
+	/**
+	 * 条件修改用户个性化参数实体，依据对象字段值(一般不建议使用该方法)
+	 * 
+	 * @param values
+	 *            被修改的键值对
+	 * @param rules
+	 *            修改条件
+	 */
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules);
+
+	/**
+	 * 条件合计用户个性化参数:count(*)
+	 * 
+	 * @param rules
+	 *            统计条件
+	 */
+	public int countEntitys(List<DBRule> rules);
+
+	/**
+	 * 获得用户对象
+	 * 
+	 * @param userId
+	 * @param parameterId
+	 * @return
+	 */
+	public Aloneparameterlocal getEntityByUser(String userId, String parameterId);
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/DictionaryEntityDaoInter.java

@@ -0,0 +1,56 @@
+package com.farm.parameter.dao;
+
+import java.util.List;
+
+import com.farm.parameter.domain.AloneDictionaryEntity;
+
+
+
+public interface DictionaryEntityDaoInter  {
+	/** 删除一个实体
+ 	 * @param entity 实体
+ 	 */
+ 	public void deleteEntity(AloneDictionaryEntity  entity) ;
+	/** 由id获得一个实体
+	 * @param id
+	 * @return
+	 */
+	public AloneDictionaryEntity  getEntity(String id) ;
+	/** 插入一条数据
+	 * @param entity
+	 */
+	public AloneDictionaryEntity insertEntity(AloneDictionaryEntity  entity);
+	/** 获得记录数量
+	 * @return
+	 */
+	public int getAllListNum();
+	/**修改一个记录
+	 * @param entity
+	 */
+	public void editEntity(AloneDictionaryEntity  entity);
+	
+	/**
+	 * 根据key查找实体
+	 * 
+	 * @param key 字段（ENTITYINDEX）
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-12-20 下午05:41:25
+	 */
+	public List<AloneDictionaryEntity> findEntityByKey(String key);
+	
+	/**
+	 * 根据key查找实体
+	 * 
+	 * @param key 字段（ENTITYINDEX）
+	 * @param exId 要排除的ID
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-12-20 下午05:41:54
+	 */
+	public List<AloneDictionaryEntity> findEntityByKey(String key, String exId);
+	/**查找所有的
+	 * @return
+	 */
+	public List<AloneDictionaryEntity> getAllEntity();
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/DictionaryTypeDaoInter.java

@@ -0,0 +1,41 @@
+package com.farm.parameter.dao;
+
+import java.util.List;
+
+import com.farm.parameter.domain.AloneDictionaryType;
+
+
+
+public interface DictionaryTypeDaoInter  {
+	/**通过entityID获得一个类型序列
+	 * @param entityId
+	 */
+	public List<AloneDictionaryType> getListByEntityId(String entityId);
+	/** 删除一个实体
+ 	 * @param entity 实体
+ 	 */
+ 	public void deleteEntity(AloneDictionaryType entity) ;
+ 	/**
+	 * 根据树索引码逻辑删除组织机构。 逻辑删除 ：修改状态为2
+	 * 
+	 * @param entityId
+	 */
+ 	public void deleteEntityByTreecode(String entityId) ;
+	/** 由id获得一个实体
+	 * @param id
+	 * @return
+	 */
+	public AloneDictionaryType getEntity(String id) ;
+	/** 插入一条数据
+	 * @param entity
+	 */
+	public void insertEntity(AloneDictionaryType entity);
+	/** 获得记录数量
+	 * @return
+	 */
+	public int getAllListNum();
+	/**修改一个记录
+	 * @param entity
+	 */
+	public void editEntity(AloneDictionaryType entity);
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/ParameterDaoInter.java

@@ -0,0 +1,92 @@
+package com.farm.parameter.dao;
+
+import java.util.List;
+import java.util.Map;
+
+import com.farm.parameter.domain.AloneParameter;
+
+
+
+public interface ParameterDaoInter {
+	/**
+	 * 删除一个实体
+	 * 
+	 * @param entity
+	 *            实体
+	 */
+	public void deleteEntity(AloneParameter entity);
+
+	/**
+	 * 由id获得一个实体
+	 * 
+	 * @param id
+	 * @return
+	 */
+	public AloneParameter getEntity(String id);
+
+	public List<AloneParameter> getAllEntity();
+
+	/**
+	 * 插入一条数据
+	 * 
+	 * @param entity
+	 */
+	public void insertEntity(AloneParameter entity);
+
+	/**
+	 * 获得记录数量
+	 * 
+	 * @return
+	 */
+	public int getAllListNum();
+
+	/**
+	 * 修改一个记录
+	 * 
+	 * @param entity
+	 */
+	public void editEntity(AloneParameter entity);
+
+	/**
+	 * 根据参数域类型查找实体集合
+	 * 
+	 * @param domainType
+	 *            ：1:系统配置；2:应用参数
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-8-30 下午05:56:27
+	 */
+	public List<Map<String, Object>> getListByDomainType(String domainType);
+
+	/**
+	 * 根据key查找实体集合
+	 * 
+	 * @param paramKey ：参数键
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-9-7 下午04:30:02
+	 */
+	public List<AloneParameter> findListByKey(String paramKey);
+
+	/**
+	 * 根据key和要排除的ID查找实体集合
+	 * 
+	 * @param paramKey ：参数键
+	 * @param excludeParamId ：要排除的系统参数ID
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-9-7 下午04:30:18
+	 */
+	public List<AloneParameter> findListByKeyAndExcludeParamId(String paramKey,
+			String excludeParamId);
+
+	/**
+	 * 根据key查找实体
+	 * 
+	 * @param paramKey 参数键
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-9-12 下午05:59:18
+	 */
+	public AloneParameter getEntityByKey(String key);
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/impl/AloneApplogDao.java

@@ -0,0 +1,198 @@
+// 声明当前类所在的包
+package  com.farm.parameter.dao.impl;
+
+// 用于处理大整数的类，适用于需要高精度整数运算的场景
+import java.math.BigInteger;
+
+// Hibernate的SQL查询类，用于执行原生SQL查询
+import org.hibernate.SQLQuery;
+// Hibernate的会话类，代表与数据库的一次交互会话
+import org.hibernate.Session;
+// Hibernate的会话工厂类，用于创建和管理Session对象
+import org.hibernate.SessionFactory;
+// Spring框架的注解，用于将该类标记为数据访问对象（DAO），并交由Spring容器管理
+import org.springframework.stereotype.Repository;
+
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.core.sql.utils.HibernateSQLTools;
+import com.farm.parameter.dao.AloneApplogDaoInter;
+import com.farm.parameter.domain.AloneApplog;
+
+// 用于存储元素的有序集合，可存储重复元素
+import java.util.List;
+// 用于存储键值对的集合，键是唯一的
+import java.util.Map;
+
+// 用于依赖注入，将Spring容器中的Bean注入到当前类的属性中
+import javax.annotation.Resource;
+
+/**
+ * 系统日志
+ * @author MAC_wd
+ */
+// 将该类标记为DAO组件，Spring会自动扫描并将其注册到容器中
+@Repository
+// 实现AloneApplogDaoInter接口，提供系统日志数据访问的具体实现
+public class AloneApplogDao implements  AloneApplogDaoInter {
+	// 使用@Resource注解注入SessionFactory对象，用于获取数据库会话
+	@Resource(name = "sessionFactory")
+	private SessionFactory sessionFatory;
+	// 用于执行Hibernate SQL操作的工具类，泛型指定为AloneApplog类型
+	private HibernateSQLTools<AloneApplog> sqlTools ;
+
+	/**
+	 * 删除单个系统日志实体
+	 * @param entity 要删除的系统日志实体对象
+	 */
+	public void deleteEntity(AloneApplog entity) {
+		// 从会话工厂获取当前会话
+		Session session=sessionFatory.getCurrentSession();
+		// 使用会话的delete方法删除指定的实体对象
+		session.delete(entity);
+	}
+
+	/**
+	 * 获取系统日志表中的记录总数
+	 * @return 系统日志表中的记录总数
+	 */
+	public int getAllListNum(){
+		// 从会话工厂获取当前会话
+		Session session= sessionFatory.getCurrentSession();
+		// 创建一个原生SQL查询，查询alone_applog表中的记录总数
+		SQLQuery sqlquery= session.createSQLQuery("select count(*) from alone_applog");
+		// 执行查询并获取结果，结果是一个BigInteger类型的对象
+		BigInteger num=(BigInteger)sqlquery.list().get(0);
+		// 将BigInteger类型的结果转换为int类型并返回
+		return num.intValue() ;
+	}
+
+	/**
+	 * 根据ID获取系统日志实体
+	 * @param id 要获取的系统日志实体的ID
+	 * @return 指定ID的系统日志实体对象，如果不存在则返回null
+	 */
+	public AloneApplog getEntity(String id) {
+		// 从会话工厂获取当前会话
+		Session session= sessionFatory.getCurrentSession();
+		// 使用会话的get方法根据ID从数据库中获取指定类型的实体对象
+		return (AloneApplog)session.get(AloneApplog.class, id);
+	}
+
+	/**
+	 * 插入一个新的系统日志实体
+	 * @param entity 要插入的系统日志实体对象
+	 * @return 插入后的系统日志实体对象
+	 */
+	public AloneApplog insertEntity(AloneApplog entity) {
+		// 从会话工厂获取当前会话
+		Session session= sessionFatory.getCurrentSession();
+		// 使用会话的save方法将实体对象保存到数据库中
+		session.save(entity);
+		// 返回插入后的实体对象
+		return entity;
+	}
+
+	/**
+	 * 编辑一个系统日志实体
+	 * @param entity 要编辑的系统日志实体对象
+	 */
+	public void editEntity(AloneApplog entity) {
+		// 从会话工厂获取当前会话
+		Session session= sessionFatory.getCurrentSession();
+		// 使用会话的update方法更新数据库中对应的实体对象
+		session.update(entity);
+	}
+
+	/**
+	 * 获取当前的Hibernate会话
+	 * @return 当前的Hibernate会话对象
+	 */
+	@Override
+	public Session getSession() {
+		// 从会话工厂获取当前会话并返回
+		return sessionFatory.getCurrentSession();
+	}
+
+	/**
+	 * 执行SQL查询并返回查询结果
+	 * @param query 数据查询对象，包含查询条件和排序规则等信息
+	 * @return 数据查询结果对象，如果查询过程中出现异常则返回null
+	 */
+	public DataResult runSqlQuery(DataQuery query){
+		try {
+			// 调用数据查询对象的search方法执行查询，并传入当前会话
+			return query.search(sessionFatory.getCurrentSession());
+		} catch (Exception e) {
+			// 如果查询过程中出现异常，返回null
+			return null;
+		}
+	}
+
+	/**
+	 * 根据规则删除系统日志实体
+	 * @param rules 用于筛选要删除实体的规则列表
+	 */
+	@Override
+	public void deleteEntitys(List<DBRule> rules) {
+		// 调用HibernateSQLTools工具类的deleteSqlFromFunction方法，根据规则删除实体
+		sqlTools.deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	/**
+	 * 根据规则查询系统日志实体列表
+	 * @param rules 用于筛选要查询实体的规则列表
+	 * @return 符合规则的系统日志实体列表
+	 */
+	@Override
+	public List<AloneApplog> selectEntitys(List<DBRule> rules) {
+		// 调用HibernateSQLTools工具类的selectSqlFromFunction方法，根据规则查询实体列表
+		return sqlTools.selectSqlFromFunction(
+				sessionFatory.getCurrentSession(), rules);
+	}
+
+	/**
+	 * 根据规则更新系统日志实体
+	 * @param values 要更新的键值对集合，键为属性名，值为新的属性值
+	 * @param rules 用于筛选要更新实体的规则列表
+	 */
+	@Override
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules) {
+		// 调用HibernateSQLTools工具类的updataSqlFromFunction方法，根据规则更新实体
+		sqlTools.updataSqlFromFunction(sessionFatory.getCurrentSession(),
+				values, rules);
+	}
+
+	/**
+	 * 获取会话工厂对象
+	 * @return 会话工厂对象
+	 */
+	public SessionFactory getSessionFatory() {
+		return sessionFatory;
+	}
+
+	/**
+	 * 设置会话工厂对象
+	 * @param sessionFatory 会话工厂对象
+	 */
+	public void setSessionFatory(SessionFactory sessionFatory) {
+		this.sessionFatory = sessionFatory;
+	}
+
+	/**
+	 * 获取Hibernate SQL工具类对象
+	 * @return Hibernate SQL工具类对象
+	 */
+	public HibernateSQLTools<AloneApplog> getSqlTools() {
+		return sqlTools;
+	}
+
+	/**
+	 * 设置Hibernate SQL工具类对象
+	 * @param sqlTools Hibernate SQL工具类对象
+	 */
+	public void setSqlTools(HibernateSQLTools<AloneApplog> sqlTools) {
+		this.sqlTools = sqlTools;
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/impl/AloneparameterlocalDaoImpl.java

@@ -0,0 +1,269 @@
+// 声明该类所在的包
+package com.farm.parameter.dao.impl;
+
+// 引入用于处理大整数的类，适用于需要高精度整数运算的场景
+import java.math.BigInteger;
+
+// Hibernate中用于执行HQL（Hibernate Query Language）查询的接口
+import org.hibernate.Query;
+// Hibernate中用于执行原生SQL查询的接口
+import org.hibernate.SQLQuery;
+// Hibernate中代表与数据库的一次交互会话的接口
+import org.hibernate.Session;
+// Hibernate中用于创建和管理Session对象的接口
+import org.hibernate.SessionFactory;
+// Spring框架的注解，用于将该类标记为数据访问对象（DAO），并交由Spring容器管理
+import org.springframework.stereotype.Repository;
+
+// 引入用户个性化参数的实体类
+import com.farm.parameter.domain.Aloneparameterlocal;
+// 引入用户个性化参数数据访问接口
+import com.farm.parameter.dao.AloneparameterlocalDaoInter;
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.core.sql.utils.HibernateSQLTools;
+
+// 引入用于存储有序元素集合的接口
+import java.util.List;
+// 引入用于存储键值对集合的接口
+import java.util.Map;
+
+// 用于依赖注入，将Spring容器中的Bean注入到当前类的属性中
+import javax.annotation.Resource;
+
+/* *
+ *功能：用户个性化参数持久层实现
+ *详细：
+ *
+ *版本：v0.1
+ *作者：王东
+ *日期：20141204174206
+ *说明：
+ */
+// 将该类标记为DAO组件，Spring会自动扫描并将其注册到容器中
+@Repository
+// 实现AloneparameterlocalDaoInter接口，提供用户个性化参数数据访问的具体实现
+public class AloneparameterlocalDaoImpl implements AloneparameterlocalDaoInter {
+	// 使用@Resource注解注入SessionFactory对象，用于获取数据库会话
+	@Resource(name = "sessionFactory")
+	private SessionFactory sessionFatory;
+	// 用于执行Hibernate SQL操作的工具类，泛型指定为Aloneparameterlocal类型
+	private HibernateSQLTools<Aloneparameterlocal> sqlTools;
+
+	/**
+	 * 删除用户个性化参数实体
+	 * @param aloneparameterlocal 要删除的用户个性化参数实体对象
+	 */
+	@Override
+	public void deleteEntity(Aloneparameterlocal aloneparameterlocal) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 从会话工厂获取当前会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的delete方法删除指定的实体对象
+		session.delete(aloneparameterlocal);
+	}
+
+	/**
+	 * 获取用户个性化参数表中的记录总数
+	 * @return 用户个性化参数表中的记录总数
+	 */
+	@Override
+	public int getAllListNum() {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 从会话工厂获取当前会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个原生SQL查询，查询farm_code_field表中的记录总数
+		SQLQuery sqlquery = session
+				.createSQLQuery("select count(*) from farm_code_field");
+		// 执行查询并获取结果，结果是一个BigInteger类型的对象
+		BigInteger num = (BigInteger) sqlquery.list().get(0);
+		// 将BigInteger类型的结果转换为int类型并返回
+		return num.intValue();
+	}
+
+	/**
+	 * 根据ID获取用户个性化参数实体
+	 * @param aloneparameterlocalid 要获取的用户个性化参数实体的ID
+	 * @return 指定ID的用户个性化参数实体对象，如果不存在则返回null
+	 */
+	@Override
+	public Aloneparameterlocal getEntity(String aloneparameterlocalid) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 从会话工厂获取当前会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的get方法根据ID从数据库中获取指定类型的实体对象
+		return (Aloneparameterlocal) session.get(Aloneparameterlocal.class,
+				aloneparameterlocalid);
+	}
+
+	/**
+	 * 插入一个新的用户个性化参数实体
+	 * @param aloneparameterlocal 要插入的用户个性化参数实体对象
+	 * @return 插入后的用户个性化参数实体对象
+	 */
+	@Override
+	public Aloneparameterlocal insertEntity(
+			Aloneparameterlocal aloneparameterlocal) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 从会话工厂获取当前会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的save方法将实体对象保存到数据库中
+		session.save(aloneparameterlocal);
+		// 返回插入后的实体对象
+		return aloneparameterlocal;
+	}
+
+	/**
+	 * 编辑一个用户个性化参数实体
+	 * @param aloneparameterlocal 要编辑的用户个性化参数实体对象
+	 */
+	@Override
+	public void editEntity(Aloneparameterlocal aloneparameterlocal) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 从会话工厂获取当前会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的update方法更新数据库中对应的实体对象
+		session.update(aloneparameterlocal);
+	}
+
+	/**
+	 * 获取当前的Hibernate会话
+	 * @return 当前的Hibernate会话对象
+	 */
+	@Override
+	public Session getSession() {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 从会话工厂获取当前会话并返回
+		return sessionFatory.getCurrentSession();
+	}
+
+	/**
+	 * 执行SQL查询并返回查询结果
+	 * @param query 数据查询对象，包含查询条件和排序规则等信息
+	 * @return 数据查询结果对象，如果查询过程中出现异常则返回null
+	 */
+	@Override
+	public DataResult runSqlQuery(DataQuery query) {
+		// TODO 自动生成代码,修改后请去除本注释
+		try {
+			// 调用数据查询对象的search方法执行查询，并传入当前会话
+			return query.search(sessionFatory.getCurrentSession());
+		} catch (Exception e) {
+			// 如果查询过程中出现异常，返回null
+			return null;
+		}
+	}
+
+	/**
+	 * 根据规则删除用户个性化参数实体
+	 * @param rules 用于筛选要删除实体的规则列表
+	 */
+	@Override
+	public void deleteEntitys(List<DBRule> rules) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 调用HibernateSQLTools工具类的deleteSqlFromFunction方法，根据规则删除实体
+		sqlTools
+				.deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	/**
+	 * 根据规则查询用户个性化参数实体列表
+	 * @param rules 用于筛选要查询实体的规则列表
+	 * @return 符合规则的用户个性化参数实体列表
+	 */
+	@Override
+	public List<Aloneparameterlocal> selectEntitys(List<DBRule> rules) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 调用HibernateSQLTools工具类的selectSqlFromFunction方法，根据规则查询实体列表
+		return sqlTools.selectSqlFromFunction(
+				sessionFatory.getCurrentSession(), rules);
+	}
+
+	/**
+	 * 根据规则更新用户个性化参数实体
+	 * @param values 要更新的键值对集合，键为属性名，值为新的属性值
+	 * @param rules 用于筛选要更新实体的规则列表
+	 */
+	@Override
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 调用HibernateSQLTools工具类的updataSqlFromFunction方法，根据规则更新实体
+		sqlTools.updataSqlFromFunction(sessionFatory.getCurrentSession(),
+				values, rules);
+	}
+
+	/**
+	 * 根据规则统计用户个性化参数实体数量
+	 * @param rules 用于筛选要统计实体的规则列表
+	 * @return 符合规则的用户个性化参数实体数量
+	 */
+	@Override
+	public int countEntitys(List<DBRule> rules) {
+		// TODO 自动生成代码,修改后请去除本注释
+		// 调用HibernateSQLTools工具类的countSqlFromFunction方法，根据规则统计实体数量
+		return sqlTools.countSqlFromFunction(sessionFatory.getCurrentSession(),
+				rules);
+	}
+
+	/**
+	 * 获取会话工厂对象
+	 * @return 会话工厂对象
+	 */
+	public SessionFactory getSessionFatory() {
+		return sessionFatory;
+	}
+
+	/**
+	 * 设置会话工厂对象
+	 * @param sessionFatory 会话工厂对象
+	 */
+	public void setSessionFatory(SessionFactory sessionFatory) {
+		this.sessionFatory = sessionFatory;
+	}
+
+	/**
+	 * 获取Hibernate SQL工具类对象
+	 * @return Hibernate SQL工具类对象
+	 */
+	public HibernateSQLTools<Aloneparameterlocal> getSqlTools() {
+		return sqlTools;
+	}
+
+	/**
+	 * 设置Hibernate SQL工具类对象
+	 * @param sqlTools Hibernate SQL工具类对象
+	 */
+	public void setSqlTools(HibernateSQLTools<Aloneparameterlocal> sqlTools) {
+		this.sqlTools = sqlTools;
+	}
+
+	/**
+	 * 根据用户ID和参数ID获取用户个性化参数实体
+	 * @param userId 用户ID
+	 * @param parameterId 参数ID
+	 * @return 符合条件的用户个性化参数实体对象，如果不存在则返回null
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public Aloneparameterlocal getEntityByUser(String userId, String parameterId) {
+		// 从会话工厂获取当前会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个HQL查询，查询Aloneparameterlocal实体中euser等于指定用户ID且parameterid等于指定参数ID的记录
+		Query sqlquery = session
+				.createQuery(" from Aloneparameterlocal where euser=? and parameterid=?");
+		// 设置查询参数，第一个参数为用户ID
+		sqlquery.setString(0, userId);
+		// 设置查询参数，第二个参数为参数ID
+		sqlquery.setString(1, parameterId);
+		// 执行查询并获取结果列表
+		List<Aloneparameterlocal> list = sqlquery.list();
+		// 如果结果列表不为空，则返回列表中的第一个元素
+		if (list.size() > 0) {
+			return list.get(0);
+		} else {
+			// 否则返回null
+			return null;
+		}
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/impl/DictionaryEntityDao.java

@@ -0,0 +1,139 @@
+package com.farm.parameter.dao.impl;
+// 导入用于处理大整数的类
+import java.math.BigInteger;
+// 导入列表接口
+import java.util.List;
+
+// 导入用于资源注入的注解
+import javax.annotation.Resource;
+
+// 导入 Hibernate 查询相关类
+import org.hibernate.Query;
+import org.hibernate.SQLQuery;
+// 导入 Hibernate 会话相关类
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+// 导入 Spring 用于标记数据访问对象的注解
+import org.springframework.stereotype.Repository;
+
+// 导入自定义的字典实体数据访问接口
+import com.farm.parameter.dao.DictionaryEntityDaoInter;
+// 导入自定义的独立字典实体类
+import com.farm.parameter.domain.AloneDictionaryEntity;
+
+// 使用 @Repository 注解将该类标记为 Spring 中的数据访问对象
+@Repository
+// 定义一个名为 DictionaryEntityDao 的类，实现 DictionaryEntityDaoInter 接口
+public class DictionaryEntityDao implements DictionaryEntityDaoInter {
+	// 使用 @Resource 注解注入名为 "sessionFactory" 的 SessionFactory 对象
+	@Resource(name = "sessionFactory")
+	// 定义一个 SessionFactory 类型的成员变量，用于获取 Hibernate 会话
+	private SessionFactory sessionFatory;
+
+	// 定义一个方法，用于删除一个独立字典实体
+	public void deleteEntity(AloneDictionaryEntity entity) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 delete 方法删除指定的实体
+		session.delete(entity);
+	}
+
+	// 定义一个方法，用于获取所有独立字典实体的数量
+	public int getAllListNum() {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个 SQL 查询对象，用于执行 SQL 查询语句
+		SQLQuery sqlquery = session
+				.createSQLQuery("select count(*) from alone_dictionary_entity ");
+		// 执行查询并获取结果列表，然后取出第一个元素并转换为 BigInteger 类型
+		BigInteger num = (BigInteger) sqlquery.list().get(0);
+		// 将 BigInteger 类型的结果转换为 int 类型并返回
+		return num.intValue();
+	}
+
+	// 定义一个方法，用于根据实体的 ID 获取独立字典实体
+	public AloneDictionaryEntity getEntity(String id) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 get 方法根据实体类和 ID 获取实体对象，并将其返回
+		return (AloneDictionaryEntity) session.get(AloneDictionaryEntity.class,
+				id);
+	}
+
+	// 定义一个方法，用于插入一个新的独立字典实体
+	public AloneDictionaryEntity insertEntity(AloneDictionaryEntity entity) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 save 方法保存实体对象
+		session.save(entity);
+		// 返回保存后的实体对象
+		return entity;
+	}
+
+	// 定义一个获取 SessionFactory 的方法
+	public SessionFactory getSessionFatory() {
+		return sessionFatory;
+	}
+
+	// 定义一个设置 SessionFactory 的方法
+	public void setSessionFatory(SessionFactory sessionFatory) {
+		this.sessionFatory = sessionFatory;
+	}
+
+	// 定义一个方法，用于编辑一个独立字典实体
+	public void editEntity(AloneDictionaryEntity entity) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 update 方法更新实体对象
+		session.update(entity);
+	}
+
+	// 使用 @SuppressWarnings 注解抑制未检查类型转换的警告
+	@SuppressWarnings("unchecked")
+	// 重写接口中的方法，根据键查找独立字典实体列表
+	@Override
+	public List<AloneDictionaryEntity> findEntityByKey(String key) {
+		// 定义 HQL 查询语句
+		String hql = "from AloneDictionaryEntity a where a.entityindex = ?";
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个 HQL 查询对象
+		Query query = session.createQuery(hql);
+		// 设置查询参数
+		query.setString(0, key);
+		// 执行查询并返回结果列表
+		return query.list();
+	}
+
+	// 使用 @SuppressWarnings 注解抑制未检查类型转换的警告
+	@SuppressWarnings("unchecked")
+	// 重写接口中的方法，根据键和排除的 ID 查找独立字典实体列表
+	@Override
+	public List<AloneDictionaryEntity> findEntityByKey(String key, String exId) {
+		// 定义 HQL 查询语句
+		String hql = "from AloneDictionaryEntity a where a.entityindex = ? and a.id != ?";
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个 HQL 查询对象
+		Query query = session.createQuery(hql);
+		// 设置查询参数
+		query.setString(0, key.trim()).setString(1, exId);
+		// 执行查询并返回结果列表
+		return query.list();
+	}
+
+	// 使用 @SuppressWarnings 注解抑制未检查类型转换的警告
+	@SuppressWarnings("unchecked")
+	// 重写接口中的方法，获取所有独立字典实体列表
+	@Override
+	public List<AloneDictionaryEntity> getAllEntity() {
+		// 定义 HQL 查询语句
+		String hql = "from AloneDictionaryEntity";
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个 HQL 查询对象
+		Query query = session.createQuery(hql);
+		// 执行查询并返回结果列表
+		return query.list();
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/impl/DictionaryTypeDao.java

@@ -0,0 +1,121 @@
+// 声明该类所在的包路径
+package com.farm.parameter.dao.impl;
+
+// 导入用于处理大整数的类
+import java.math.BigInteger;
+// 导入列表接口
+import java.util.List;
+
+// 导入用于资源注入的注解
+import javax.annotation.Resource;
+
+// 导入 Hibernate 查询相关类
+import org.hibernate.Query;
+import org.hibernate.SQLQuery;
+// 导入 Hibernate 会话相关类
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+// 导入 Spring 用于标记数据访问对象的注解
+import org.springframework.stereotype.Repository;
+
+// 导入自定义的字典类型数据访问接口
+import com.farm.parameter.dao.DictionaryTypeDaoInter;
+// 导入自定义的独立字典类型类
+import com.farm.parameter.domain.AloneDictionaryType;
+
+// 使用 @Repository 注解将该类标记为 Spring 中的数据访问对象
+@Repository
+// 定义一个名为 DictionaryTypeDao 的类，实现 DictionaryTypeDaoInter 接口
+public class DictionaryTypeDao implements DictionaryTypeDaoInter {
+	// 使用 @Resource 注解注入名为 "sessionFactory" 的 SessionFactory 对象
+	@Resource(name = "sessionFactory")
+	// 定义一个 SessionFactory 类型的成员变量，用于获取 Hibernate 会话
+	private SessionFactory sessionFatory;
+
+	// 定义一个方法，用于删除一个独立字典类型实体
+	public void deleteEntity(AloneDictionaryType entity) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 delete 方法删除指定的实体
+		session.delete(entity);
+	}
+
+	// 重写接口中的方法，根据树编码删除相关的独立字典类型实体
+	@Override
+	public void deleteEntityByTreecode(String entityId) {
+		// 原本注释掉的 HQL 语句，用于更新实体状态为 '2'
+		//String hql = "update AloneDictionaryType a set a.state = '2' "
+		//        + "where a.treecode like ?";
+		// 实际使用的 HQL 语句，用于删除树编码包含指定 entityId 的实体
+		String hql = "delete from AloneDictionaryType a where a.treecode like ?";
+		// 创建一个 HQL 查询对象
+		Query query = sessionFatory.getCurrentSession().createQuery(hql);
+		// 设置查询参数，使用 '%' 进行模糊匹配
+		query.setString(0, "%" + entityId + "%");
+		// 执行更新操作
+		query.executeUpdate();
+	}
+
+	// 定义一个方法，用于获取所有独立字典类型实体的数量
+	public int getAllListNum() {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个 SQL 查询对象，用于执行 SQL 查询语句
+		SQLQuery sqlquery = session
+				.createSQLQuery("select count(*) from alone_dictionary_type");
+		// 执行查询并获取结果列表，然后取出第一个元素并转换为 BigInteger 类型
+		BigInteger num = (BigInteger) sqlquery.list().get(0);
+		// 将 BigInteger 类型的结果转换为 int 类型并返回
+		return num.intValue();
+	}
+
+	// 定义一个方法，用于根据实体的 ID 获取独立字典类型实体
+	public AloneDictionaryType getEntity(String id) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 get 方法根据实体类和 ID 获取实体对象，并将其返回
+		return (AloneDictionaryType) session.get(AloneDictionaryType.class, id);
+	}
+
+	// 定义一个方法，用于插入一个新的独立字典类型实体
+	public void insertEntity(AloneDictionaryType entity) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 save 方法保存实体对象
+		session.save(entity);
+	}
+
+	// 定义一个获取 SessionFactory 的方法
+	public SessionFactory getSessionFatory() {
+		return sessionFatory;
+	}
+
+	// 定义一个设置 SessionFactory 的方法
+	public void setSessionFatory(SessionFactory sessionFatory) {
+		this.sessionFatory = sessionFatory;
+	}
+
+	// 定义一个方法，用于编辑一个独立字典类型实体
+	public void editEntity(AloneDictionaryType entity) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 使用会话的 update 方法更新实体对象
+		session.update(entity);
+	}
+
+	// 使用 @SuppressWarnings 注解抑制未检查类型转换的警告
+	@SuppressWarnings("unchecked")
+	// 重写接口中的方法，根据实体 ID 获取独立字典类型实体列表
+	@Override
+	public List<AloneDictionaryType> getListByEntityId(String entityId) {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个 HQL 查询对象，并设置查询参数
+		Query query = session.createQuery("from AloneDictionaryType where entity=?")
+				.setString(0, entityId);
+		// 执行查询并将结果存储在列表中
+		List<AloneDictionaryType> list = query.list();
+		// 返回查询结果列表
+		return list;
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/dao/impl/ParameterDao.java

@@ -0,0 +1,142 @@
+package com.farm.parameter.dao.impl;
+
+import java.math.BigInteger;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Resource;
+
+import org.hibernate.Query;
+import org.hibernate.SQLQuery;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.springframework.stereotype.Repository;
+
+import com.farm.core.sql.result.DataResults;
+import com.farm.parameter.dao.ParameterDaoInter;
+import com.farm.parameter.domain.AloneParameter;
+
+@Repository
+public class ParameterDao implements ParameterDaoInter {
+	@Resource(name = "sessionFactory")
+	private SessionFactory sessionFatory;
+
+	public void deleteEntity(AloneParameter entity) {
+		// TODO Auto-generated method stub
+		Session session = sessionFatory.getCurrentSession();
+		session.delete(entity);
+	}
+
+	public int getAllListNum() {
+		Session session = sessionFatory.getCurrentSession();
+		SQLQuery sqlquery = session.createSQLQuery("select count(*) from Alone_Parameter");
+		BigInteger num = (BigInteger) sqlquery.list().get(0);
+		return num.intValue();
+	}
+
+	public AloneParameter getEntity(String id) {
+		// TODO Auto-generated method stub
+		Session session = sessionFatory.getCurrentSession();
+		return (AloneParameter) session.get(AloneParameter.class, id);
+	}
+
+	public void insertEntity(AloneParameter entity) {
+		// TODO Auto-generated method stub
+		Session session = sessionFatory.getCurrentSession();
+		session.save(entity);
+	}
+
+	public SessionFactory getSessionFatory() {
+		return sessionFatory;
+	}
+
+	public void setSessionFatory(SessionFactory sessionFatory) {
+		this.sessionFatory = sessionFatory;
+	}
+
+	public void editEntity(AloneParameter entity) {
+		// TODO Auto-generated method stub
+		Session session = sessionFatory.getCurrentSession();
+		session.update(entity);
+	}
+	// 重写接口中的方法，用于获取所有的参数实体列表
+	@Override
+	public List<AloneParameter> getAllEntity() {
+		// 从 SessionFactory 获取当前的 Hibernate 会话
+		Session session = sessionFatory.getCurrentSession();
+		// 创建一个 HQL 查询对象，查询所有的 AloneParameter 实体
+		Query sqlquery = session.createQuery("from AloneParameter");
+		// 抑制未检查类型转换的警告
+		@SuppressWarnings("unchecked")
+		// 执行查询并将结果存储在列表中
+		List<AloneParameter> list = sqlquery.list();
+		// 返回查询结果列表
+		return list;
+	}
+
+	// 抑制未检查类型转换的警告
+	@SuppressWarnings("unchecked")
+// 重写接口中的方法，根据域类型获取参数列表，返回的是包含键值对的映射列表
+	@Override
+	public List<Map<String, Object>> getListByDomainType(String domainType) {
+		// 定义 SQL 查询语句，选择指定列，根据域类型筛选并按更新时间降序排序
+		String sql = "select a.id, a.name, a.vtype, a.rules, a.pvalue, a.comments " + "from ALONE_PARAMETER a "//
+				+ "where a.domain = ? " //
+				+ "order by a.utime desc";
+		// 创建一个 SQL 查询对象
+		SQLQuery sqlQuery = sessionFatory.getCurrentSession().createSQLQuery(sql);
+		// 设置查询参数，即域类型
+		sqlQuery.setString(0, domainType);
+		// 调用 DataResults 的 getMaps 方法将查询结果转换为包含键值对的映射列表并返回
+		return DataResults.getMaps("id, name, vtype, rules, pvalue, comments", sqlQuery.list());
+	}
+
+	// 抑制未检查类型转换的警告
+	@SuppressWarnings("unchecked")
+// 重写接口中的方法，根据参数键查找参数实体列表
+	@Override
+	public List<AloneParameter> findListByKey(String paramKey) {
+		// 定义 HQL 查询语句，根据参数键筛选
+		String hql = "from AloneParameter a where a.pkey = ?";
+		// 创建一个 HQL 查询对象
+		Query query = sessionFatory.getCurrentSession().createQuery(hql);
+		// 设置查询参数，去除参数键前后的空格
+		query.setString(0, paramKey.trim());
+		// 执行查询并返回结果列表
+		return query.list();
+	}
+
+	// 抑制未检查类型转换的警告
+	@SuppressWarnings("unchecked")
+// 重写接口中的方法，根据参数键查找参数实体列表，并排除指定 ID 的参数
+	@Override
+	public List<AloneParameter> findListByKeyAndExcludeParamId(String paramKey, String excludeParamId) {
+		// 定义 HQL 查询语句，根据参数键筛选并排除指定 ID 的参数
+		String hql = "from AloneParameter a where a.pkey = ? and a.id != ?";
+		// 创建一个 HQL 查询对象
+		Query query = sessionFatory.getCurrentSession().createQuery(hql);
+		// 设置查询参数，去除参数键前后的空格并指定排除的参数 ID
+		query.setString(0, paramKey.trim()).setString(1, excludeParamId);
+		// 执行查询并返回结果列表
+		return query.list();
+	}
+
+	// 重写接口中的方法，根据参数键获取单个参数实体
+	@Override
+	public AloneParameter getEntityByKey(String key) {
+		// 创建一个 HQL 查询对象，根据参数键筛选
+		Query sqlquery = sessionFatory.getCurrentSession().createQuery("from AloneParameter where PKEY=?");
+		// 设置查询参数，去除参数键前后的空格
+		sqlquery.setString(0, key.trim());
+		// 抑制未检查类型转换的警告
+		@SuppressWarnings("unchecked")
+		// 执行查询并将结果存储在列表中
+		List<AloneParameter> list = sqlquery.list();
+		// 如果列表中有元素，返回第一个元素
+		if (list.size() > 0) {
+			return list.get(0);
+		} else {
+			// 否则返回 null
+			return null;
+		}
+	}

src/wcp-parameter/src/main/java/com/farm/parameter/domain/AloneApplog.java

@@ -0,0 +1,177 @@
+// 声明该类所在的包
+package com.farm.parameter.domain;
+
+// 导入 JPA 注解，用于映射数据库列
+import javax.persistence.Column;
+// 导入 JPA 注解，用于将类标记为实体类
+import javax.persistence.Entity;
+// 导入 JPA 注解，用于指定主键的生成策略
+import javax.persistence.GeneratedValue;
+// 导入 JPA 注解，用于标记主键字段
+import javax.persistence.Id;
+// 导入 JPA 注解，用于指定数据库表名
+import javax.persistence.Table;
+
+// 导入 Hibernate 提供的注解，用于自定义主键生成器
+import org.hibernate.annotations.GenericGenerator;
+
+// 使用 @Entity 注解将该类标记为 JPA 实体类，指定实体名称为 "AloneApplog"
+@Entity(name = "AloneApplog")
+// 使用 @Table 注解指定该实体对应的数据库表名为 "alone_applog"
+@Table(name = "alone_applog")
+// 定义 AloneApplog 类，实现 Serializable 接口，表明该类的对象可以被序列化
+public class AloneApplog implements java.io.Serializable {
+
+	// 定义类的静态常量 serialVersionUID，用于序列化版本控制
+	private static final long serialVersionUID = 5377999273280487349L;
+
+	// 使用 @Id 注解标记该字段为主键
+	@Id
+	// 使用 @GenericGenerator 注解定义一个名为 "systemUUID" 的主键生成器，使用 "uuid" 策略生成 UUID
+	@GenericGenerator(name = "systemUUID", strategy = "uuid")
+	// 使用 @GeneratedValue 注解指定使用 "systemUUID" 生成器来生成主键值
+	@GeneratedValue(generator = "systemUUID")
+	// 使用 @Column 注解指定该字段对应数据库表中的 "ID" 列，长度为 32，可插入、可更新，且不能为空
+	@Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+	// 定义一个字符串类型的字段 id，用于存储实体的唯一标识
+	private String id;
+
+	// 使用 @Column 注解指定该字段对应数据库表中的 "CTIME" 列，长度为 16，不能为空
+	@Column(name = "CTIME", length = 16, nullable = false)
+	// 定义一个字符串类型的字段 ctime，用于存储创建时间
+	private String ctime;
+
+	// 使用 @Column 注解指定该字段对应数据库表中的 "DESCRIBES" 列，长度为 1024，不能为空
+	@Column(name = "DESCRIBES", length = 1024, nullable = false)
+	// 定义一个字符串类型的字段 describes，用于存储描述信息
+	private String describes;
+
+	// 使用 @Column 注解指定该字段对应数据库表中的 "APPUSER" 列，长度为 32，不能为空
+	@Column(name = "APPUSER", length = 32, nullable = false)
+	// 定义一个字符串类型的字段 appuser，用于存储应用用户信息
+	private String appuser;
+
+	// 使用 @Column 注解指定该字段对应数据库表中的 "LEVELS" 列，长度为 32
+	@Column(name = "LEVELS", length = 32)
+	// 定义一个字符串类型的字段 levels，用于存储日志级别信息
+	private String levels;
+
+	// 使用 @Column 注解指定该字段对应数据库表中的 "METHOD" 列，长度为 128
+	@Column(name = "METHOD", length = 128)
+	// 定义一个字符串类型的字段 method，用于存储方法信息
+	private String method;
+
+	// 使用 @Column 注解指定该字段对应数据库表中的 "CLASSNAME" 列，长度为 128
+	@Column(name = "CLASSNAME", length = 128)
+	// 定义一个字符串类型的字段 classname，用于存储类名信息
+	private String classname;
+
+	// 使用 @Column 注解指定该字段对应数据库表中的 "IP" 列，长度为 32
+	@Column(name = "IP", length = 32)
+	// 定义一个字符串类型的 定义一个字符串类型的字段 ip，用于存储 IP 地址信息
+	private String ip;
+
+	// 定义无参构造函数
+	public AloneApplog() {
+	}
+
+	// 定义带三个参数的构造函数，用于初始化创建时间、描述信息和应用用户信息
+	public AloneApplog(String ctime, String describes, String appuser) {
+		this.ctime = ctime;
+		this.describes = describes;
+		this.appuser = appuser;
+	}
+
+	// 定义带七个参数的构造函数，用于初始化所有字段信息
+	public AloneApplog(String ctime, String describes, String appuser,
+					   String levels, String method, String classname, String ip) {
+		this.ctime = ctime;
+		this.describes = describes;
+		this.appuser = appuser;
+		this.levels = levels;
+		this.method = method;
+		this.classname = classname;
+		this.ip = ip;
+	}
+
+	// 定义获取 id 字段值的方法
+	public String getId() {
+		return this.id;
+	}
+
+	// 定义设置 id 字段值的方法
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	// 定义获取 ctime 字段值的方法
+	public String getCtime() {
+		return this.ctime;
+	}
+
+	// 定义设置 ctime 字段值的方法
+	public void setCtime(String ctime) {
+		this.ctime = ctime;
+	}
+
+	// 定义获取 describes 字段值的方法
+	public String getDescribes() {
+		return this.describes;
+	}
+
+	// 定义设置 describes 字段值的方法
+	public void setDescribes(String describes) {
+		this.describes = describes;
+	}
+
+	// 定义获取 appuser 字段值的方法
+	public String getAppuser() {
+		return this.appuser;
+	}
+
+	// 定义设置 appuser 字段值的方法
+	public void setAppuser(String appuser) {
+		this.appuser = appuser;
+	}
+
+	// 定义获取 levels 字段值的方法
+	public String getLevels() {
+		return levels;
+	}
+
+	// 定义设置 levels 字段值的方法
+	public void setLevels(String levels) {
+		this.levels = levels;
+	}
+
+	// 定义获取 method 字段值的方法
+	public String getMethod() {
+		return this.method;
+	}
+
+	// 定义设置 method 字段值的方法
+	public void setMethod(String method) {
+		this.method = method;
+	}
+
+	// 定义获取 classname 字段值的方法
+	public String getClassname() {
+		return this.classname;
+	}
+
+	// 定义设置 classname 字段值的方法
+	public void setClassname(String classname) {
+		this.classname = classname;
+	}
+
+	// 定义获取 ip 字段值的方法
+	public String getIp() {
+		return this.ip;
+	}
+
+	// 定义设置 ip 字段值的方法
+	public void setIp(String ip) {
+		this.ip = ip;
+	}
+
+}

src/wcp-parameter/src/main/java/com/farm/parameter/domain/AloneDictionaryEntity.java

@@ -0,0 +1,236 @@
+// 声明该类所属的包
+package com.farm.parameter.domain;
+
+// 导入 JPA 用于映射数据库列的注解
+import javax.persistence.Column;
+// 导入 JPA 用于将类标记为实体类的注解
+import javax.persistence.Entity;
+// 导入 JPA 用于指定主键生成方式的注解
+import javax.persistence.GeneratedValue;
+// 导入 JPA 用于标记主键字段的注解
+import javax.persistence.Id;
+// 导入 JPA 用于指定实体对应的数据库表名的注解
+import javax.persistence.Table;
+
+// 导入 Hibernate 自定义主键生成器的注解
+import org.hibernate.annotations.GenericGenerator;
+
+/**
+ * AloneDictionaryEntity 实体类。该类由 MyEclipse Persistence Tools 工具生成。
+ */
+// 使用 @Entity 注解将该类标记为 JPA 实体类，并指定实体名称
+@Entity(name = "AloneDictionaryEntity")
+// 使用 @Table 注解指定该实体对应的数据库表名
+@Table(name = "alone_dictionary_entity")
+// 让该类实现 Serializable 接口，以便对象可以被序列化和反序列化
+public class AloneDictionaryEntity implements java.io.Serializable {
+
+	// 定义序列化版本号，用于确保序列化和反序列化过程中类的版本一致性
+	private static final long serialVersionUID = 3910748672120707433L;
+
+	// 使用 @Id 注解标记该字段为主键
+	@Id
+	// 定义一个名为 "systemUUID" 的主键生成器，采用 "uuid" 策略生成 UUID
+	@GenericGenerator(name = "systemUUID", strategy = "uuid")
+	// 指定使用 "systemUUID" 生成器来生成主键值
+	@GeneratedValue(generator = "systemUUID")
+	// 映射数据库中的 "ID" 列，指定列的长度、是否可插入、可更新以及是否可为空
+	@Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+	// 存储实体的唯一标识符
+	private String id;
+
+	// 映射数据库中的 "CTIME" 列，指定列的长度和是否可为空
+	@Column(name = "CTIME", length = 12, nullable = false)
+	// 存储创建时间
+	private String ctime;
+
+	// 映射数据库中的 "UTIME" 列，指定列的长度和是否可为空
+	@Column(name = "UTIME", length = 12, nullable = false)
+	// 存储更新时间
+	private String utime;
+
+	// 映射数据库中的 "CUSER" 列，指定列的长度和是否可为空
+	@Column(name = "CUSER", length = 32, nullable = false)
+	// 存储创建用户
+	private String cuser;
+
+	// 映射数据库中的 "MUSER" 列，指定列的长度和是否可为空
+	@Column(name = "MUSER", length = 32, nullable = false)
+	// 存储修改用户
+	private String muser;
+
+	// 映射数据库中的 "STATE" 列，指定列的长度和是否可为空
+	@Column(name = "STATE", length = 1, nullable = false)
+	// 存储实体状态
+	private String state;
+
+	// 映射数据库中的 "NAME" 列，指定列的长度和是否可为空
+	@Column(name = "NAME", length = 128, nullable = false)
+	// 存储实体名称
+	private String name;
+
+	// 映射数据库中的 "ENTITYINDEX" 列，指定列的长度和是否可为空
+	@Column(name = "ENTITYINDEX", length = 128, nullable = false)
+	// 存储实体索引
+	private String entityindex;
+
+	// 映射数据库中的 "COMMENTS" 列，指定列的长度
+	@Column(name = "COMMENTS", length = 128)
+	// 存储实体备注信息
+	private String comments;
+
+	// 映射数据库中的 "TYPE" 列，指定列的长度和是否可为空
+	@Column(name = "TYPE", length = 1, nullable = false)
+	// 存储实体类型
+	private String type;
+
+	// 无参构造函数，用于创建一个空的 AloneDictionaryEntity 对象
+	public AloneDictionaryEntity() {
+	}
+
+	/**
+	 * 最小化构造函数，用于创建一个包含部分必要信息的 AloneDictionaryEntity 对象
+	 * @param ctime 创建时间
+	 * @param utime 更新时间
+	 * @param cuser 创建用户
+	 * @param muser 修改用户
+	 * @param state 实体状态
+	 * @param name 实体名称
+	 * @param entityindex 实体索引
+	 */
+	public AloneDictionaryEntity(String ctime, String utime, String cuser,
+								 String muser, String state, String name, String entityindex) {
+		this.ctime = ctime;
+		this.utime = utime;
+		this.cuser = cuser;
+		this.muser = muser;
+		this.state = state;
+		this.name = name;
+		this.entityindex = entityindex;
+	}
+
+	/**
+	 * 完整构造函数，用于创建一个包含所有信息的 AloneDictionaryEntity 对象
+	 * @param ctime 创建时间
+	 * @param utime 更新时间
+	 * @param cuser 创建用户
+	 * @param muser 修改用户
+	 * @param state 实体状态
+	 * @param name 实体名称
+	 * @param entityindex 实体索引
+	 * @param comments 实体备注信息
+	 */
+	public AloneDictionaryEntity(String ctime, String utime, String cuser,
+								 String muser, String state, String name, String entityindex,
+								 String comments) {
+		this.ctime = ctime;
+		this.utime = utime;
+		this.cuser = cuser;
+		this.muser = muser;
+		this.state = state;
+		this.name = name;
+		this.entityindex = entityindex;
+		this.comments = comments;
+	}
+
+	// 获取实体唯一标识符的方法
+	public String getId() {
+		return this.id;
+	}
+
+	// 设置实体唯一标识符的方法
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	// 获取创建时间的方法
+	public String getCtime() {
+		return this.ctime;
+	}
+
+	// 设置创建时间的方法
+	public void setCtime(String ctime) {
+		this.ctime = ctime;
+	}
+
+	// 获取更新时间的方法
+	public String getUtime() {
+		return this.utime;
+	}
+
+	// 设置更新时间的方法
+	public void setUtime(String utime) {
+		this.utime = utime;
+	}
+
+	// 获取创建用户的方法
+	public String getCuser() {
+		return this.cuser;
+	}
+
+	// 设置创建用户的方法
+	public void setCuser(String cuser) {
+		this.cuser = cuser;
+	}
+
+	// 获取修改用户的方法
+	public String getMuser() {
+		return this.muser;
+	}
+
+	// 设置修改用户的方法
+	public void setMuser(String muser) {
+		this.muser = muser;
+	}
+
+	// 获取实体状态的方法
+	public String getState() {
+		return this.state;
+	}
+
+	// 设置实体状态的方法
+	public void setState(String state) {
+		this.state = state;
+	}
+
+	// 获取实体名称的方法
+	public String getName() {
+		return this.name;
+	}
+
+	// 设置实体名称的方法
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	// 获取实体索引的方法
+	public String getEntityindex() {
+		return this.entityindex;
+	}
+
+	// 设置实体索引的方法
+	public void setEntityindex(String entityindex) {
+		this.entityindex = entityindex;
+	}
+
+	// 获取实体备注信息的方法
+	public String getComments() {
+		return this.comments;
+	}
+
+	// 设置实体备注信息的方法
+	public void setComments(String comments) {
+		this.comments = comments;
+	}
+
+	// 获取实体类型的方法
+	public String getType() {
+		return type;
+	}
+
+	// 设置实体类型的方法
+	public void setType(String type) {
+		this.type = type;
+	}
+
+}

src/wcp-parameter/src/main/java/com/farm/parameter/domain/AloneDictionaryType.java

@@ -0,0 +1,292 @@
+// 声明该类所属的包
+package com.farm.parameter.domain;
+
+// 导入用于处理大数值的类，这里用于处理可能的排序数值
+import java.math.BigDecimal;
+
+// 导入 JPA 用于映射数据库列的注解
+import javax.persistence.Column;
+// 导入 JPA 用于将类标记为实体类的注解
+import javax.persistence.Entity;
+// 导入 JPA 用于指定主键生成方式的注解
+import javax.persistence.GeneratedValue;
+// 导入 JPA 用于标记主键字段的注解
+import javax.persistence.Id;
+// 导入 JPA 用于指定实体对应的数据库表名的注解
+import javax.persistence.Table;
+
+// 导入 Hibernate 自定义主键生成器的注解
+import org.hibernate.annotations.GenericGenerator;
+
+/**
+ * AloneDictionaryType 实体类。该类由 MyEclipse Persistence Tools 工具生成。
+ */
+// 使用 @Entity 注解将该类标记为 JPA 实体类，并指定实体名称
+@Entity(name = "AloneDictionaryType")
+// 使用 @Table 注解指定该实体对应的数据库表名
+@Table(name = "alone_dictionary_type")
+// 让该类实现 Serializable 接口，以便对象可以被序列化和反序列化
+public class AloneDictionaryType implements java.io.Serializable {
+
+	// 定义类的静态常量 serialVersionUID，用于序列化版本控制，确保在反序列化时类的结构兼容性
+	private static final long serialVersionUID = 4237493054556172783L;
+
+	// 使用 @Id 注解标记该字段为主键
+	@Id
+	// 定义一个名为 "systemUUID" 的主键生成器，采用 "uuid" 策略生成 UUID 作为主键值
+	@GenericGenerator(name = "systemUUID", strategy = "uuid")
+	// 指定使用 "systemUUID" 生成器来生成主键值
+	@GeneratedValue(generator = "systemUUID")
+	// 映射数据库中的 "ID" 列，指定列的长度为 32，允许插入、更新操作，且该列不能为空
+	@Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+	// 声明一个字符串类型的成员变量 id，用于存储实体的唯一标识符
+	private String id;
+
+	// 映射数据库中的 "CTIME" 列，指定列的长度为 12，该列不能为空
+	@Column(name = "CTIME", length = 12, nullable = false)
+	// 声明一个字符串类型的成员变量 ctime，用于存储实体的创建时间
+	private String ctime;
+
+	// 映射数据库中的 "UTIME" 列，指定列的长度为 12，该列不能为空
+	@Column(name = "UTIME", length = 12, nullable = false)
+	// 声明一个字符串类型的成员变量 utime，用于存储实体的更新时间
+	private String utime;
+
+	// 映射数据库中的 "CUSER" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "CUSER", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 cuser，用于存储创建该实体的用户信息
+	private String cuser;
+
+	// 映射数据库中的 "MUSER" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "MUSER", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 muser，用于存储修改该实体的用户信息
+	private String muser;
+
+	// 映射数据库中的 "STATE" 列，指定列的长度为 1，该列不能为空
+	@Column(name = "STATE", length = 1, nullable = false)
+	// 声明一个字符串类型的成员变量 state，用于存储实体的状态信息
+	private String state;
+
+	// 映射数据库中的 "NAME" 列，指定列的长度为 128，该列不能为空
+	@Column(name = "NAME", length = 128, nullable = false)
+	// 声明一个字符串类型的成员变量 name，用于存储实体的名称
+	private String name;
+
+	// 映射数据库中的 "COMMENTS" 列，指定列的长度为 128
+	@Column(name = "COMMENTS", length = 128)
+	// 声明一个字符串类型的成员变量 comments，用于存储实体的注释信息
+	private String comments;
+
+	// 映射数据库中的 "ENTITYTYPE" 列，指定列的长度为 128，该列不能为空
+	@Column(name = "ENTITYTYPE", length = 128, nullable = false)
+	// 声明一个字符串类型的成员变量 entitytype，用于存储实体的类型信息
+	private String entitytype;
+
+	// 映射数据库中的 "ENTITY" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "ENTITY", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 entity，用于存储与该实体相关的某个实体标识
+	private String entity;
+
+	// 映射数据库中的 "SORT" 列，指定列的长度为 11，该列不能为空
+	@Column(name = "SORT", length = 11, nullable = false)
+	// 声明一个 BigDecimal 类型的成员变量 sort，用于存储实体的排序信息
+	private BigDecimal sort;
+
+	// 映射数据库中的 "PARENTID" 列，指定列的长度为 32
+	@Column(name = "PARENTID", length = 32)
+	// 声明一个字符串类型的成员变量 parentid，用于存储该实体的父节点标识
+	private String parentid;
+
+	// 映射数据库中的 "TREECODE" 列，指定列的长度为 256
+	@Column(name = "TREECODE", length = 256)
+	// 声明一个字符串类型的成员变量 treecode，用于存储实体的树状结构编码
+	private String treecode;
+
+	// 无参构造函数，用于创建一个空的 AloneDictionaryType 对象
+	public AloneDictionaryType() {
+	}
+
+	/**
+	 * 最小化构造函数，用于创建一个包含部分必要信息的 AloneDictionaryType 对象
+	 * @param ctime 创建时间
+	 * @param utime 更新时间
+	 * @param cuser 创建用户
+	 * @param muser 修改用户
+	 * @param state 实体状态
+	 * @param name 实体名称
+	 * @param entitytype 实体类型
+	 * @param entity 相关实体标识
+	 * @param sort 排序信息
+	 */
+	public AloneDictionaryType(String ctime, String utime, String cuser,
+							   String muser, String state, String name, String entitytype,
+							   String entity, BigDecimal sort) {
+		this.ctime = ctime;
+		this.utime = utime;
+		this.cuser = cuser;
+		this.muser = muser;
+		this.state = state;
+		this.name = name;
+		this.entitytype = entitytype;
+		this.entity = entity;
+		this.sort = sort;
+	}
+
+	/**
+	 * 完整构造函数，用于创建一个包含所有信息的 AloneDictionaryType 对象
+	 * @param ctime 创建时间
+	 * @param utime 更新时间
+	 * @param cuser 创建用户
+	 * @param muser 修改用户
+	 * @param state 实体状态
+	 * @param name 实体名称
+	 * @param comments 注释信息
+	 * @param entitytype 实体类型
+	 * @param entity 相关实体标识
+	 * @param sort 排序信息
+	 */
+	public AloneDictionaryType(String ctime, String utime, String cuser,
+							   String muser, String state, String name, String comments,
+							   String entitytype, String entity, BigDecimal sort) {
+		this.ctime = ctime;
+		this.utime = utime;
+		this.cuser = cuser;
+		this.muser = muser;
+		this.state = state;
+		this.name = name;
+		this.comments = comments;
+		this.entitytype = entitytype;
+		this.entity = entity;
+		this.sort = sort;
+	}
+
+	// 获取实体唯一标识符的方法
+	public String getId() {
+		return this.id;
+	}
+
+	// 设置实体唯一标识符的方法
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	// 获取实体创建时间的方法
+	public String getCtime() {
+		return this.ctime;
+	}
+
+	// 设置实体创建时间的方法
+	public void setCtime(String ctime) {
+		this.ctime = ctime;
+	}
+
+	// 获取实体更新时间的方法
+	public String getUtime() {
+		return this.utime;
+	}
+
+	// 设置实体更新时间的方法
+	public void setUtime(String utime) {
+		this.utime = utime;
+	}
+
+	// 获取实体创建用户的方法
+	public String getCuser() {
+		return this.cuser;
+	}
+
+	// 设置实体创建用户的方法
+	public void setCuser(String cuser) {
+		this.cuser = cuser;
+	}
+
+	// 获取实体修改用户的方法
+	public String getMuser() {
+		return this.muser;
+	}
+
+	// 设置实体修改用户的方法
+	public void setMuser(String muser) {
+		this.muser = muser;
+	}
+
+	// 获取实体状态的方法
+	public String getState() {
+		return this.state;
+	}
+
+	// 设置实体状态的方法
+	public void setState(String state) {
+		this.state = state;
+	}
+
+	// 获取实体名称的方法
+	public String getName() {
+		return this.name;
+	}
+
+	// 设置实体名称的方法
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	// 获取实体注释信息的方法
+	public String getComments() {
+		return this.comments;
+	}
+
+	// 设置实体注释信息的方法
+	public void setComments(String comments) {
+		this.comments = comments;
+	}
+
+	// 获取实体类型的方法
+	public String getEntitytype() {
+		return this.entitytype;
+	}
+
+	// 设置实体类型的方法
+	public void setEntitytype(String entitytype) {
+		this.entitytype = entitytype;
+	}
+
+	// 获取相关实体标识的方法
+	public String getEntity() {
+		return this.entity;
+	}
+
+	// 设置相关实体标识的方法
+	public void setEntity(String entity) {
+		this.entity = entity;
+	}
+
+	// 获取实体排序信息的方法
+	public BigDecimal getSort() {
+		return this.sort;
+	}
+
+	// 设置实体排序信息的方法
+	public void setSort(BigDecimal sort) {
+		this.sort = sort;
+	}
+
+	// 获取实体父节点标识的方法
+	public String getParentid() {
+		return parentid;
+	}
+
+	// 设置实体父节点标识的方法
+	public void setParentid(String parentid) {
+		this.parentid = parentid;
+	}
+
+	// 获取实体树状结构编码的方法
+	public String getTreecode() {
+		return treecode;
+	}
+
+	// 设置实体树状结构编码的方法
+	public void setTreecode(String treecode) {
+		this.treecode = treecode;
+	}
+}}

src/wcp-parameter/src/main/java/com/farm/parameter/domain/AloneParameter.java

@@ -0,0 +1,309 @@
+// 声明该类所属的包
+package com.farm.parameter.domain;
+
+// 导入 JPA 用于映射数据库列的注解
+import javax.persistence.Column;
+// 导入 JPA 用于将类标记为实体类的注解
+import javax.persistence.Entity;
+// 导入 JPA 用于指定主键生成方式的注解
+import javax.persistence.GeneratedValue;
+// 导入 JPA 用于标记主键字段的注解
+import javax.persistence.Id;
+// 导入 JPA 用于指定实体对应的数据库表名的注解
+import javax.persistence.Table;
+
+// 导入 Hibernate 自定义主键生成器的注解
+import org.hibernate.annotations.GenericGenerator;
+
+/**
+ * AloneParameter 实体类。该类由 MyEclipse Persistence Tools 工具生成。
+ */
+// 使用 @Entity 注解将该类标记为 JPA 实体类，并指定实体名称
+@Entity(name = "AloneParameter")
+// 使用 @Table 注解指定该实体对应的数据库表名
+@Table(name = "alone_parameter")
+// 让该类实现 Serializable 接口，以便对象可以被序列化和反序列化
+public class AloneParameter implements java.io.Serializable {
+
+	// 定义类的静态常量 serialVersionUID，用于序列化版本控制，确保在反序列化时类的结构兼容性
+	private static final long serialVersionUID = -6930414361030223374L;
+
+	// 使用 @Id 注解标记该字段为主键
+	@Id
+	// 定义一个名为 "systemUUID" 的主键生成器，采用 "uuid" 策略生成 UUID 作为主键值
+	@GenericGenerator(name = "systemUUID", strategy = "uuid")
+	// 指定使用 "systemUUID" 生成器来生成主键值
+	@GeneratedValue(generator = "systemUUID")
+	// 映射数据库中的 "ID" 列，指定列的长度为 32，允许插入、更新操作，且该列不能为空
+	@Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+	// 声明一个字符串类型的成员变量 id，用于存储实体的唯一标识符
+	private String id;
+
+	// 映射数据库中的 "CTIME" 列，指定列的长度为 12，该列不能为空
+	@Column(name = "CTIME", length = 12, nullable = false)
+	// 声明一个字符串类型的成员变量 ctime，用于存储实体的创建时间
+	private String ctime;
+
+	// 映射数据库中的 "UTIME" 列，指定列的长度为 12，该列不能为空
+	@Column(name = "UTIME", length = 12, nullable = false)
+	// 声明一个字符串类型的成员变量 utime，用于存储实体的更新时间
+	private String utime;
+
+	// 映射数据库中的 "CUSER" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "CUSER", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 cuser，用于存储创建该实体的用户信息
+	private String cuser;
+
+	// 映射数据库中的 "MUSER" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "MUSER", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 muser，用于存储修改该实体的用户信息
+	private String muser;
+
+	// 映射数据库中的 "NAME" 列，指定列的长度为 128，该列不能为空
+	@Column(name = "NAME", length = 128, nullable = false)
+	// 声明一个字符串类型的成员变量 name，用于存储实体的名称
+	private String name;
+
+	// 映射数据库中的 "STATE" 列，指定列的长度为 1，该列不能为空
+	@Column(name = "STATE", length = 1, nullable = false)
+	// 声明一个字符串类型的成员变量 state，用于存储实体的状态信息
+	private String state;
+
+	// 映射数据库中的 "PKEY" 列，指定列的长度为 64，该列不能为空
+	@Column(name = "PKEY", length = 64, nullable = false)
+	// 声明一个字符串类型的成员变量 pkey，可能用于存储参数的键
+	private String pkey;
+
+	// 映射数据库中的 "PVALUE" 列，指定列的长度为 2048，该列不能为空
+	@Column(name = "PVALUE", length = 2048, nullable = false)
+	// 声明一个字符串类型的成员变量 pvalue，可能用于存储参数的值
+	private String pvalue;
+
+	// 映射数据库中的 "RULES" 列，指定列的长度为 256
+	@Column(name = "RULES", length = 256)
+	// 声明一个字符串类型的成员变量 rules，可能用于存储参数的规则
+	private String rules;
+
+	// 映射数据库中的 "DOMAIN" 列，指定列的长度为 64
+	@Column(name = "DOMAIN", length = 64)
+	// 声明一个字符串类型的成员变量 domain，可能用于存储参数所属的域
+	private String domain;
+
+	// 映射数据库中的 "COMMENTS" 列，指定列的长度为 256
+	@Column(name = "COMMENTS", length = 256)
+	// 声明一个字符串类型的成员变量 comments，用于存储实体的注释信息
+	private String comments;
+
+	// 映射数据库中的 "VTYPE" 列，指定列的长度为 1，该列不能为空
+	@Column(name = "VTYPE", length = 1, nullable = false)
+	// 声明一个字符串类型的成员变量 vtype，可能用于存储参数的类型
+	private String vtype;
+
+	// 映射数据库中的 "USERABLE" 列，指定列的长度为 1，该列不能为空
+	@Column(name = "USERABLE", length = 1, nullable = false)
+	// 声明一个字符串类型的成员变量 userable，可能用于存储参数是否可被用户使用的标识
+	private String userable;
+
+	// 无参构造函数，用于创建一个空的 AloneParameter 对象
+	public AloneParameter() {
+	}
+
+	/**
+	 * 最小化构造函数，用于创建一个包含部分必要信息的 AloneParameter 对象
+	 * @param ctime 创建时间
+	 * @param utime 更新时间
+	 * @param cuser 创建用户
+	 * @param muser 修改用户
+	 * @param name 实体名称
+	 * @param state 实体状态
+	 * @param pkey 参数键
+	 * @param pvalue 参数值
+	 * @param vtype 参数类型
+	 */
+	public AloneParameter(String ctime, String utime, String cuser,
+						  String muser, String name, String state, String pkey,
+						  String pvalue, String vtype) {
+		this.ctime = ctime;
+		this.utime = utime;
+		this.cuser = cuser;
+		this.muser = muser;
+		this.name = name;
+		this.state = state;
+		this.pkey = pkey;
+		this.pvalue = pvalue;
+		this.vtype = vtype;
+	}
+
+	/**
+	 * 完整构造函数，用于创建一个包含所有信息的 AloneParameter 对象
+	 * @param ctime 创建时间
+	 * @param utime 更新时间
+	 * @param cuser 创建用户
+	 * @param muser 修改用户
+	 * @param name 实体名称
+	 * @param state 实体状态
+	 * @param pkey 参数键
+	 * @param pvalue 参数值
+	 * @param rules 参数规则
+	 * @param domain 参数所属域
+	 * @param comments 注释信息
+	 * @param vtype 参数类型
+	 */
+	public AloneParameter(String ctime, String utime, String cuser,
+						  String muser, String name, String state, String pkey,
+						  String pvalue, String rules, String domain, String comments,
+						  String vtype) {
+		this.ctime = ctime;
+		this.utime = utime;
+		this.cuser = cuser;
+		this.muser = muser;
+		this.name = name;
+		this.state = state;
+		this.pkey = pkey;
+		this.pvalue = pvalue;
+		this.rules = rules;
+		this.domain = domain;
+		this.comments = comments;
+		this.vtype = vtype;
+	}
+
+	// 获取实体唯一标识符的方法
+	public String getId() {
+		return this.id;
+	}
+
+	// 设置实体唯一标识符的方法
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	// 获取实体创建时间的方法
+	public String getCtime() {
+		return this.ctime;
+	}
+
+	// 设置实体创建时间的方法
+	public void setCtime(String ctime) {
+		this.ctime = ctime;
+	}
+
+	// 获取实体更新时间的方法
+	public String getUtime() {
+		return this.utime;
+	}
+
+	// 设置实体更新时间的方法
+	public void setUtime(String utime) {
+		this.utime = utime;
+	}
+
+	// 获取实体创建用户的方法
+	public String getCuser() {
+		return this.cuser;
+	}
+
+	// 设置实体创建用户的方法
+	public void setCuser(String cuser) {
+		this.cuser = cuser;
+	}
+
+	// 获取实体修改用户的方法
+	public String getMuser() {
+		return this.muser;
+	}
+
+	// 设置实体修改用户的方法
+	public void setMuser(String muser) {
+		this.muser = muser;
+	}
+
+	// 获取实体名称的方法
+	public String getName() {
+		return this.name;
+	}
+
+	// 设置实体名称的方法
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	// 获取实体状态的方法
+	public String getState() {
+		return this.state;
+	}
+
+	// 设置实体状态的方法
+	public void setState(String state) {
+		this.state = state;
+	}
+
+	// 获取参数键的方法
+	public String getPkey() {
+		return this.pkey;
+	}
+
+	// 设置参数键的方法
+	public void setPkey(String pkey) {
+		this.pkey = pkey;
+	}
+
+	// 获取参数值的方法
+	public String getPvalue() {
+		return this.pvalue;
+	}
+
+	// 设置参数值的方法
+	public void setPvalue(String pvalue) {
+		this.pvalue = pvalue;
+	}
+
+	// 获取参数规则的方法
+	public String getRules() {
+		return this.rules;
+	}
+
+	// 设置参数规则的方法
+	public void setRules(String rules) {
+		this.rules = rules;
+	}
+
+	// 获取参数所属域的方法
+	public String getDomain() {
+		return this.domain;
+	}
+
+	// 设置参数所属域的方法
+	public void setDomain(String domain) {
+		this.domain = domain;
+	}
+
+	// 获取注释信息的方法
+	public String getComments() {
+		return this.comments;
+	}
+
+	// 设置注释信息的方法
+	public void setComments(String comments) {
+		this.comments = comments;
+	}
+
+	// 获取参数类型的方法
+	public String getVtype() {
+		return this.vtype;
+	}
+
+	// 设置参数类型的方法
+	public void setVtype(String vtype) {
+		this.vtype = vtype;
+	}
+
+	// 获取参数是否可被用户使用标识的方法
+	public String getUserable() {
+		return userable;
+	}
+
+	// 设置参数是否可被用户使用标识的方法
+	public void setUserable(String userable) {
+		this.userable = userable;
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/domain/Aloneparameterlocal.java

@@ -0,0 +1,103 @@
+// 声明该类所属的包
+package com.farm.parameter.domain;
+
+// 导入 JPA 用于映射数据库列的注解
+import javax.persistence.Column;
+// 导入 JPA 用于将类标记为实体类的注解
+import javax.persistence.Entity;
+// 导入 JPA 用于指定主键生成方式的注解
+import javax.persistence.GeneratedValue;
+// 导入 JPA 用于标记主键字段的注解
+import javax.persistence.Id;
+// 导入 JPA 用于指定实体对应的数据库表名的注解
+import javax.persistence.Table;
+
+// 导入 Hibernate 自定义主键生成器的注解
+import org.hibernate.annotations.GenericGenerator;
+
+/*
+ *功能：用户个性化参数类
+ *详细：
+ *
+ *版本：v0.1
+ *作者：王东
+ *日期：20141204174206
+ *说明：
+ */
+// 使用 @Entity 注解将该类标记为 JPA 实体类，并指定实体名称
+@Entity(name = "Aloneparameterlocal")
+// 使用 @Table 注解指定该实体对应的数据库表名
+@Table(name = "alone_parameter_local")
+// 让该类实现 Serializable 接口，以便对象可以被序列化和反序列化
+public class Aloneparameterlocal implements java.io.Serializable {
+
+	// 定义类的静态常量 serialVersionUID，用于序列化版本控制，这里设置为 1
+	private static final long serialVersionUID = 1L;
+
+	// 映射数据库中的 "PVALUE" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "PVALUE", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 pvalue，可能用于存储参数值
+	private String pvalue;
+
+	// 映射数据库中的 "EUSER" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "EUSER", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 euser，可能用于存储相关用户信息
+	private String euser;
+
+	// 映射数据库中的 "PARAMETERID" 列，指定列的长度为 32，该列不能为空
+	@Column(name = "PARAMETERID", length = 32, nullable = false)
+	// 声明一个字符串类型的成员变量 parameterid，可能用于存储参数的标识
+	private String parameterid;
+
+	// 使用 @Id 注解标记该字段为主键
+	@Id
+	// 定义一个名为 "systemUUID" 的主键生成器，采用 "uuid" 策略生成 UUID 作为主键值
+	@GenericGenerator(name = "systemUUID", strategy = "uuid")
+	// 指定使用 "systemUUID" 生成器来生成主键值
+	@GeneratedValue(generator = "systemUUID")
+	// 映射数据库中的 "ID" 列，指定列的长度为 32，允许插入、更新操作，且该列不能为空
+	@Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+	// 声明一个字符串类型的成员变量 id，用于存储实体的唯一标识符
+	private String id;
+
+	// 获取参数值的方法
+	public String getPvalue() {
+		return this.pvalue;
+	}
+
+	// 设置参数值的方法
+	public void setPvalue(String pvalue) {
+		this.pvalue = pvalue;
+	}
+
+	// 获取相关用户信息的方法
+	public String getEuser() {
+		return this.euser;
+	}
+
+	// 设置相关用户信息的方法
+	public void setEuser(String euser) {
+		this.euser = euser;
+	}
+
+	// 获取参数标识的方法
+	public String getParameterid() {
+		return this.parameterid;
+	}
+
+	// 设置参数标识的方法
+	public void setParameterid(String parameterid) {
+		this.parameterid = parameterid;
+	}
+
+	// 获取实体唯一标识符的方法
+	public String getId() {
+		return this.id;
+	}
+
+	// 设置实体唯一标识符的方法
+	public void setId(String id) {
+		this.id = id;
+	}
+}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/exception/KeyExistException.java

@@ -0,0 +1,10 @@
+package com.farm.parameter.exception;
+
+public class KeyExistException extends Exception {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -6064027268304270441L;
+
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/AloneApplogServiceInter.java

@@ -0,0 +1,48 @@
+package com.farm.parameter.service;
+
+import com.farm.core.auth.domain.LoginUser;
+import com.farm.parameter.domain.AloneApplog;
+
+
+/**系统日志
+ * @author MAC_wd
+ *
+ */
+public interface AloneApplogServiceInter {
+	/**
+	 *新增实体
+	 * 
+	 * @param entity
+	 */
+	public AloneApplog insertEntity(AloneApplog entity,LoginUser user);
+	/**
+	 *修改实体
+	 * 
+	 * @param entity
+	 */
+	public AloneApplog editEntity(AloneApplog entity,LoginUser user);
+	/**
+	 *删除实体
+	 * 
+	 * @param entity
+	 */
+	public void deleteEntity(String entity,LoginUser user);
+	/**
+	 *获得实体
+	 * 
+	 * @param id
+	 * @return
+	 */
+	public AloneApplog getEntity(String id);
+	
+	/**写入日志
+	 * @param describes 内容
+	 * @param appuser 操作人
+	 * @param level 日志等级
+	 * @param method 方法
+	 * @param classname 类
+	 * @param ip 
+	 * @return
+	 */
+	public AloneApplog log(String describes,String appuser,String level,String method,String classname,String ip);
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/DictionaryEntityServiceInter.java

@@ -0,0 +1,76 @@
+package com.farm.parameter.service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.farm.parameter.domain.AloneDictionaryEntity;
+import com.farm.core.auth.domain.LoginUser;
+
+public interface DictionaryEntityServiceInter {
+
+	public void deleteEntity(String entity, LoginUser user);
+
+	public AloneDictionaryEntity editEntity(AloneDictionaryEntity entity,
+			LoginUser user);
+
+	public AloneDictionaryEntity getEntity(String id);
+
+	public AloneDictionaryEntity insertEntity(AloneDictionaryEntity entity,
+			LoginUser user);
+
+	/**
+	 * 验证key是否重复
+	 * 
+	 * @param key
+	 *            字段（ENTITYINDEX）
+	 * @param exId
+	 *            要排除的ID
+	 * @return
+	 * @author liuchao
+	 * @time 2012-12-20 下午05:36:09
+	 */
+	public boolean validateIsRepeatKey(String key, String exId);
+
+	/**
+	 * 修改备注。如果备注内容为空，则用“字典类型”的值填充备注。 格式为json，例：{采煤:1, 掘进:2, 开拓:3, 机电:4}
+	 * 
+	 * @param id
+	 *            数据字典ID
+	 * @author liuchao
+	 * @time 2012-12-21 上午10:55:53
+	 */
+	public void editComments(String id);
+
+	/**
+	 * 查询所有的数据字典对象
+	 * 
+	 * @return
+	 */
+	public List<AloneDictionaryEntity> getAllEntity();
+
+	/**
+	 * 获得数据字典
+	 * 
+	 * @param key
+	 * @return
+	 */
+	public Map<String, String> getDictionary(String key);
+
+	/**
+	 * 获得字典列表
+	 * 
+	 * @param key
+	 * @return
+	 */
+	public List<Entry<String, String>> getDictionaryList(String key);
+
+	/**
+	 * 由字典id获得key
+	 * 
+	 * @param dicId
+	 * @return
+	 */
+	public String getDicKey(String dicId);
+
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/DictionaryTypeServiceInter.java

@@ -0,0 +1,24 @@
+package com.farm.parameter.service;
+
+import com.farm.parameter.domain.AloneDictionaryType;
+import com.farm.core.auth.domain.LoginUser;
+
+
+public interface DictionaryTypeServiceInter {
+	/**
+	 * 通过一个键获得一个应用配置字符串值
+	 */
+	public String getConfigValue(String key);
+
+
+	public void deleteEntity(String entity, LoginUser user);
+
+	public AloneDictionaryType editEntity(AloneDictionaryType entity,
+			LoginUser user);
+
+	public AloneDictionaryType getEntity(String id);
+
+	public AloneDictionaryType insertEntity(AloneDictionaryType entity,
+			LoginUser user);
+
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/ParameterServiceInter.java

@@ -0,0 +1,143 @@
+package com.farm.parameter.service;
+
+import java.util.List;
+import java.util.Map;
+
+import com.farm.parameter.domain.AloneParameter;
+import com.farm.parameter.exception.KeyExistException;
+import com.farm.core.auth.domain.LoginUser;
+
+public interface ParameterServiceInter {
+	public final String CURRENCY_YES = "0";
+	public final String CURRENCY_USER = "1";
+	public final String TYPE_GENERAL = "0";
+	public final String TYPE_DECORDE = "1";
+	public final String TYPE_MD5 = "2";
+
+	/**
+	 * 修改系统参数的默认值
+	 * 
+	 * @param paramId
+	 *            ：系统参数ID
+	 * @param pValue
+	 *            ：参数值
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-9-9 上午09:41:08
+	 */
+	public void setValue(String key, String pValue,
+			LoginUser aloneUser);
+
+	/**
+	 * 修改系统参数的个性化值
+	 * 
+	 * @param paramId
+	 *            ：系统参数ID
+	 * @param pValue
+	 *            ：参数值
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-9-9 上午09:41:08
+	 */
+	public void setUserValue(String key, String pValue,
+			LoginUser aloneUser);
+
+	/**
+	 * 获得所有系统参数
+	 * 
+	 * @return
+	 */
+	public List<Map<String, Object>> getAllParameters();
+
+	/**
+	 * 获得允许用户自定义的系统参数
+	 * 
+	 * @return
+	 */
+	public List<Map<String, Object>> getUserParameters(
+			String userid);
+
+	/**
+	 * 获得参数值(1.用户个性化参数.或2.默认参数.)
+	 * @param key 参数键
+	 * @param userId 用户id
+	 * @return
+	 */
+	public String getValue(String key,String userId);
+	public String getValue(String key);
+
+	// -----------------------------------------------------------------------------
+
+	/**
+	 * 新增一条参数定义
+	 * 
+	 * @param entity
+	 * @param domain
+	 *            可以为参数选择一个域（相当于一个参数分类）
+	 * @throws HaveIndexException
+	 */
+	public AloneParameter insertEntity(AloneParameter entity, String domain,
+			LoginUser aloneUser) throws KeyExistException;
+
+	/**
+	 * 删除一个参数定义
+	 * 
+	 * @param entity
+	 * @param user
+	 */
+	public void deleteEntity(String parameterId, LoginUser user);
+
+	/**
+	 * 修改一个参数定义
+	 * 
+	 * @param entity
+	 * @param aloneUser
+	 * @return
+	 */
+	public AloneParameter editEntity(AloneParameter entity, LoginUser aloneUser);
+
+	/**
+	 * 强制刷新配置集合(刷新参数缓存)
+	 */
+	public boolean refreshCache();
+
+	/**
+	 * 根据参数域类型获取转换好的list集合。如：将字符串解析为list，页面组合为下拉选。
+	 * 
+	 * @author zhang_hc
+	 * @param domainType
+	 *            ：参数域类型（1：系统配置页；2：应用参数页）。说明：“系统参数管理”页面按导航栏分开
+	 * @time 2012-8-28 下午02:59:08
+	 */
+	public List<Map<String, Object>> getTransParamList(String domainType);
+
+	/**
+	 * 验证是否是重复key
+	 * 
+	 * @param paramKey
+	 *            ：“参数键”名称
+	 * @param excludeParamId
+	 *            ：要排除的系统参数ID
+	 * @return 重复：true；不重复：false
+	 * @author zhang_hc
+	 * @time 2012-9-7 下午01:00:14
+	 */
+	public boolean isRepeatKey(String paramKey, String excludeParamId);
+
+	/**
+	 * 根据key查找实体
+	 * 
+	 * @param paramKey
+	 *            参数键
+	 * @return
+	 * @author zhang_hc
+	 * @time 2012-9-12 下午05:59:18
+	 */
+	public AloneParameter findEntityByKey(String paramKey);
+
+	/**
+	 * @param id
+	 * @return
+	 */
+	public AloneParameter getEntity(String parameterId);
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/impl/AloneApplogServiceImpl.java

@@ -0,0 +1,105 @@
+// 声明该类所属的包
+package com.farm.parameter.service.impl;
+
+// 导入用于资源注入的注解
+import javax.annotation.Resource;
+
+// 导入 Spring 用于标记服务类的注解
+import org.springframework.stereotype.Service;
+// 导入 Spring 用于声明事务的注解
+import org.springframework.transaction.annotation.Transactional;
+
+// 导入自定义的 AloneApplog 数据访问接口
+import com.farm.parameter.dao.AloneApplogDaoInter;
+// 导入自定义的 AloneApplog 实体类
+import com.farm.parameter.domain.AloneApplog;
+// 导入自定义的登录用户实体类
+import com.farm.core.auth.domain.LoginUser;
+// 导入自定义的时间工具类
+import com.farm.core.time.TimeTool;
+// 导入自定义的 AloneApplog 服务接口
+import com.farm.parameter.service.AloneApplogServiceInter;
+
+/**
+ * 系统日志
+ *
+ * @author MAC_wd
+ */
+// 使用 @Service 注解将该类标记为 Spring 中的服务类
+@Service
+// 定义 AloneApplogServiceImpl 类，实现 AloneApplogServiceInter 接口
+public class AloneApplogServiceImpl implements AloneApplogServiceInter {
+	// 使用 @Resource 注解注入 AloneApplogDaoInter 类型的对象
+	@Resource
+	private AloneApplogDaoInter aloneApplogDao;
+
+	// 实现接口中的插入实体方法，用于插入一个 AloneApplog 实体
+	public AloneApplog insertEntity(AloneApplog entity, LoginUser user) {
+		// 原本被注释掉的代码，可能是用于设置实体的创建时间、结束时间、创建用户和修改用户
+		// entity.setCtime(TimeTool.getTimeDate12());
+		// entity.setEtime(TimeTool.getTimeDate12());
+		// entity.setCuser(user.getId());
+		// entity.setEuser(user.getId());
+		// 调用数据访问层的 insertEntity 方法插入实体，并返回插入后的实体
+		return aloneApplogDao.insertEntity(entity);
+	}
+
+	// 实现接口中的编辑实体方法，用于编辑一个 AloneApplog 实体
+	public AloneApplog editEntity(AloneApplog entity, LoginUser user) {
+		// 根据实体的 ID 从数据访问层获取原实体
+		AloneApplog entity2 = aloneApplogDao.getEntity(entity.getId());
+		// 原本被注释掉的代码，可能是用于设置原实体的结束时间和修改用户
+		// entity2.setEtime(TimeTool.getTimeDate12());
+		// entity2.setEuser(user.getId());
+		// 将传入实体的部分属性值更新到原实体上
+		entity2.setCtime(entity.getCtime());
+		entity2.setDescribes(entity.getDescribes());
+		entity2.setAppuser(entity.getAppuser());
+		entity2.setLevels(entity.getLevels());
+		entity2.setMethod(entity.getMethod());
+		entity2.setClassname(entity.getClassname());
+		// 调用数据访问层的 editEntity 方法更新实体
+		aloneApplogDao.editEntity(entity2);
+		// 返回更新后的实体
+		return entity2;
+	}
+
+	// 实现接口中的删除实体方法，用于删除一个 AloneApplog 实体
+	public void deleteEntity(String entity, LoginUser user) {
+		// 根据传入的实体 ID 获取实体，并调用数据访问层的 deleteEntity 方法删除实体
+		aloneApplogDao.deleteEntity(aloneApplogDao.getEntity(entity));
+	}
+
+	// 使用 @Transactional 注解声明该方法支持事务
+	@Transactional
+	// 实现接口中的获取实体方法，用于根据 ID 获取一个 AloneApplog 实体
+	public AloneApplog getEntity(String id) {
+		// 如果 ID 为 null，则直接返回 null
+		if (id == null) {
+			return null;
+		}
+		// 调用数据访问层的 getEntity 方法获取实体并返回
+		return aloneApplogDao.getEntity(id);
+	}
+
+	// 获取 AloneApplogDaoInter 对象的方法
+	public AloneApplogDaoInter getaloneApplogDao() {
+		return aloneApplogDao;
+	}
+
+	// 设置 AloneApplogDaoInter 对象的方法
+	public void setaloneApplogDao(AloneApplogDaoInter dao) {
+		this.aloneApplogDao = dao;
+	}
+
+	// 重写接口中的 log 方法，用于记录系统日志
+	@Override
+	@Transactional
+	public AloneApplog log(String describes, String appuser, String level,
+						   String method, String classname, String ip) {
+		// 创建一个新的 AloneApplog 实体，并设置相关属性，然后调用数据访问层的 insertEntity 方法插入实体并返回
+		return aloneApplogDao.insertEntity(new AloneApplog(TimeTool
+				.getTimeDate14(), describes, appuser, level, method, classname,
+				ip));
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/impl/ConstantVarService.java

@@ -0,0 +1,57 @@
+// 声明该类所属的包
+package com.farm.parameter.service.impl;
+
+// 导入用于操作可变数组列表的类
+import java.util.ArrayList;
+// 导入用于操作键值对映射的类
+import java.util.HashMap;
+// 导入用于操作列表的接口
+import java.util.List;
+// 导入用于操作映射的接口
+import java.util.Map;
+// 导入用于遍历映射条目的接口
+import java.util.Map.Entry;
+
+// 导入 Spring 用于标记服务类的注解
+import org.springframework.stereotype.Service;
+
+// 导入自定义的读取配置键的类
+import com.farm.core.config.ReadKey;
+
+// 使用 @Service 注解将该类标记为 Spring 中的服务类
+@Service
+// 定义 ConstantVarService 类，用于管理常量变量
+public class ConstantVarService {
+	// 定义一个静态的 Map，用于存储常量的键值对，键和值都是字符串类型
+	private static Map<String, String> constant = new HashMap<String, String>();
+
+	// 定义一个静态方法，用于注册常量，接受一个键和一个值作为参数
+	public static void registConstant(String key, String value) {
+		// 将键值对存入 constant 映射中
+		constant.put(key, value);
+		// 判断是否存在键为 "farm.constant.webroot.path" 的常量值
+		if (getValue("farm.constant.webroot.path") != null) {
+			// 如果存在，则调用 ReadKey 类的 read 方法，传入该键对应的值作为参数
+			ReadKey.read(getValue("farm.constant.webroot.path"));
+		}
+	}
+
+	// 定义一个静态方法，用于获取 constant 映射中所有的键值对条目
+	public static List<Entry<String, String>> getEntrys() {
+		// 创建一个新的 ArrayList，用于存储键值对条目
+		List<Entry<String, String>> list = new ArrayList<Entry<String, String>>();
+		// 遍历 constant 映射中的所有键值对条目
+		for (Entry<String, String> node : constant.entrySet()) {
+			// 将每个键值对条目添加到 list 中
+			list.add(node);
+		}
+		// 返回存储了所有键值对条目的 list
+		return list;
+	}
+
+	// 定义一个静态方法，用于根据键获取对应的值
+	public static String getValue(String key) {
+		// 从 constant 映射中获取指定键对应的值，并返回
+		return constant.get(key);
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/impl/DictionaryEntityServiceImpl.java

@@ -0,0 +1,345 @@
+// 声明该类所属的包
+package com.farm.parameter.service.impl;
+
+// 导入处理 SQL 异常的类
+import java.sql.SQLException;
+// 导入用于操作可变数组列表的类
+import java.util.ArrayList;
+// 导入用于操作键值对映射的类
+import java.util.HashMap;
+// 导入用于迭代集合的迭代器接口
+import java.util.Iterator;
+// 导入用于操作列表的接口
+import java.util.List;
+// 导入用于操作映射的接口
+import java.util.Map;
+// 导入用于创建简单键值对条目的类
+import java.util.AbstractMap.SimpleEntry;
+// 导入用于遍历映射条目的接口
+import java.util.Map.Entry;
+
+// 导入用于资源注入的注解
+import javax.annotation.Resource;
+
+// 导入 Spring 用于标记服务类的注解
+import org.springframework.stereotype.Service;
+// 导入 Spring 用于声明事务的注解
+import org.springframework.transaction.annotation.Transactional;
+
+// 导入自定义的字典实体数据访问接口
+import com.farm.parameter.dao.DictionaryEntityDaoInter;
+// 导入自定义的字典类型数据访问接口
+import com.farm.parameter.dao.DictionaryTypeDaoInter;
+// 导入自定义的独立字典实体类
+import com.farm.parameter.domain.AloneDictionaryEntity;
+// 导入自定义的独立字典类型类
+import com.farm.parameter.domain.AloneDictionaryType;
+// 导入自定义的登录用户实体类
+import com.farm.core.auth.domain.LoginUser;
+// 导入自定义的数据库规则类，用于构建查询条件
+import com.farm.core.sql.query.DBRule;
+// 导入自定义的数据库排序类，用于指定查询结果的排序方式
+import com.farm.core.sql.query.DBSort;
+// 导入自定义的数据查询类，用于执行数据库查询操作
+import com.farm.core.sql.query.DataQuery;
+// 导入自定义的数据结果类，用于处理查询结果
+import com.farm.core.sql.result.DataResult;
+// 导入自定义的时间工具类
+import com.farm.core.time.TimeTool;
+// 导入自定义的字典实体服务接口
+import com.farm.parameter.service.DictionaryEntityServiceInter;
+
+// 使用 @Service 注解将该类标记为 Spring 中的服务类
+@Service
+// 定义 DictionaryEntityServiceImpl 类，实现 DictionaryEntityServiceInter 接口
+public class DictionaryEntityServiceImpl implements
+		DictionaryEntityServiceInter {
+	// 使用 @Resource 注解注入 DictionaryEntityDaoInter 类型的对象
+	@Resource
+	private DictionaryEntityDaoInter dictionaryentityDao;
+	// 使用 @Resource 注解注入 DictionaryTypeDaoInter 类型的对象
+	@Resource
+	private DictionaryTypeDaoInter dictionarytypeDao;
+	// 定义一个静态的 Map，用于缓存字典类型数据，键为字符串，值为独立字典类型的列表
+	protected static final Map<String, List<AloneDictionaryType>> dicCache = new HashMap<String, List<AloneDictionaryType>>();
+
+	// 重写接口中的删除实体方法，声明该方法支持事务
+	@Override
+	@Transactional
+	public void deleteEntity(String entity, LoginUser user) {
+		// 根据实体 ID 获取相关的字典类型列表
+		List<AloneDictionaryType> list = dictionarytypeDao
+				.getListByEntityId(entity);
+		// 遍历字典类型列表
+		for (Iterator<AloneDictionaryType> iterator = list.iterator(); iterator
+				.hasNext();) {
+			// 获取当前的字典类型对象
+			AloneDictionaryType aloneDictionaryType = (AloneDictionaryType) iterator
+					.next();
+			// 删除当前的字典类型对象
+			dictionarytypeDao.deleteEntity(aloneDictionaryType);
+		}
+		// 删除对应的字典实体对象
+		dictionaryentityDao.deleteEntity(dictionaryentityDao.getEntity(entity));
+	}
+
+	// 重写接口中的编辑实体方法，声明该方法支持事务
+	@Override
+	@Transactional
+	public AloneDictionaryEntity editEntity(AloneDictionaryEntity entity,
+											LoginUser user) {
+		// 从缓存中移除与该实体索引相关的缓存数据
+		dicCache.remove(entity.getEntityindex());
+		// 验证键是否重复
+		if (validateIsRepeatKey(entity.getEntityindex(), entity.getId())) {
+			// 如果键已存在，抛出非法参数异常
+			throw new IllegalArgumentException("字典KEY已经存在");
+		}
+		// 根据实体 ID 获取原实体对象
+		AloneDictionaryEntity entity2 = getEntity(entity.getId());
+		// 更新原实体的备注信息
+		entity2.setComments(entity.getComments());
+		// 更新原实体的名称，并去除名称两端的空格
+		entity2.setName(entity.getName().trim());
+		// 更新原实体的实体索引，并去除索引两端的空格（必须去空格）
+		entity2.setEntityindex(entity.getEntityindex().trim());
+		// 更新原实体的更新时间
+		entity2.setUtime(TimeTool.getTimeDate12());
+		// 更新原实体的修改用户 ID
+		entity2.setMuser(user.getId());
+		// 更新原实体的类型
+		entity2.setType(entity.getType());
+		// 调用数据访问层的方法更新实体
+		dictionaryentityDao.editEntity(entity2);
+		// 返回更新后的实体
+		return entity2;
+	}
+
+	// 获取所有字典实体的方法
+	public List<AloneDictionaryEntity> getAllEntity() {
+		// 调用数据访问层的方法获取所有字典实体
+		return dictionaryentityDao.getAllEntity();
+	}
+
+	// 获取所有字典实体数量的方法，当前返回 0，可能需要进一步实现
+	public int getAllListNum() {
+		return 0;
+	}
+
+	// 重写接口中的获取实体方法，声明该方法支持事务
+	@Override
+	@Transactional
+	public AloneDictionaryEntity getEntity(String id) {
+		// 如果 ID 为 null，直接返回 null
+		if (id == null)
+			return null;
+		// 调用数据访问层的方法根据 ID 获取实体
+		return dictionaryentityDao.getEntity(id);
+	}
+
+	// 重写接口中的插入实体方法，声明该方法支持事务
+	@Override
+	@Transactional
+	public AloneDictionaryEntity insertEntity(AloneDictionaryEntity entity,
+											  LoginUser user) {
+		// 验证键是否重复
+		if (validateIsRepeatKey(entity.getEntityindex(), null)) {
+			// 如果键已存在，抛出非法参数异常
+			throw new IllegalArgumentException("字典KEY已经存在");
+		}
+		// 设置实体的创建时间
+		entity.setCtime(TimeTool.getTimeDate12());
+		// 设置实体的创建用户 ID
+		entity.setCuser(user.getId());
+		// 设置实体的更新时间
+		entity.setUtime(TimeTool.getTimeDate12());
+		// 设置实体的修改用户 ID
+		entity.setMuser(user.getId());
+		// 设置实体的状态为 "1"
+		entity.setState("1");
+		// 设置实体的名称，并去除名称两端的空格
+		entity.setName(entity.getName().trim());
+		// 设置实体的实体索引，并去除索引两端的空格（必须去空格）
+		entity.setEntityindex(entity.getEntityindex().trim());
+		// 调用数据访问层的方法插入实体，并返回插入后的实体
+		return dictionaryentityDao.insertEntity(entity);
+	}
+
+	// 获取 DictionaryEntityDaoInter 对象的方法
+	public DictionaryEntityDaoInter getdictionaryentityDao() {
+		return dictionaryentityDao;
+	}
+
+	// 重写接口中的验证键是否重复的方法，声明该方法支持事务
+	@Override
+	@Transactional
+	public boolean validateIsRepeatKey(String key, String exId) {
+		// 定义一个列表用于存储查询结果
+		List<AloneDictionaryEntity> list = null;
+		// 如果排除 ID 为 null 或为空字符串
+		if (exId == null || exId.trim().equals("")) {
+			// 根据键查询字典实体列表
+			list = dictionaryentityDao.findEntityByKey(key.trim());
+		} else {
+			// 根据键和排除 ID 查询字典实体列表
+			list = dictionaryentityDao.findEntityByKey(key.trim(), exId.trim());
+		}
+		// 如果查询结果列表的大小大于 0，说明键已存在，返回 true；否则返回 false
+		return list.size() > 0;
+	}
+}
+
+		// 重写接口中的 editComments 方法，用于编辑字典实体的备注信息
+		@Override
+		public void editComments(String id) {
+			// 检查传入的 id 是否为 null 或者空字符串，如果是则直接返回，不进行后续操作
+			if (id == null || id.equals("")) {
+				return;
+			}
+
+			// 根据传入的 id 从数据库中获取对应的 AloneDictionaryEntity 实体对象
+			AloneDictionaryEntity dicEntity = dictionaryentityDao.getEntity(id);
+			// 以下代码被注释掉了，原本的逻辑可能是如果实体的备注信息不为空且不为空字符串则直接返回
+			// if(dicEntity.getComments()!=null&&!dicEntity.getComments().equals("")){
+			// return;
+			// }
+
+			// 根据实体 id 从数据库中获取对应的 AloneDictionaryType 类型列表
+			List<AloneDictionaryType> dictypeList = dictionarytypeDao
+					.getListByEntityId(id);
+			// 检查获取到的类型列表是否为空，如果为空则直接返回，不进行后续操作
+			if (dictypeList.isEmpty()) {
+				return;
+			}
+
+			// 创建一个 StringBuilder 对象，用于构建新的备注信息
+			StringBuilder sBuilder = new StringBuilder();
+			// 向 StringBuilder 中添加左花括号，作为备注信息的起始部分
+			sBuilder.append("{");
+			// 遍历获取到的 AloneDictionaryType 类型列表
+			for (AloneDictionaryType itDictype : dictypeList) {
+				// 获取当前类型的名称
+				String name = itDictype.getName();
+				// 获取当前类型的实体类型
+				String entitytype = itDictype.getEntitytype();
+				// 向 StringBuilder 中添加名称、冒号、实体类型和逗号空格
+				sBuilder.append(name).append(":").append(entitytype).append(", ");
+			}
+			// 删除 StringBuilder 中最后添加的逗号和空格
+			sBuilder.delete(sBuilder.length() - 2, sBuilder.length());
+			// 向 StringBuilder 中添加右花括号，作为备注信息的结束部分
+			sBuilder.append("}");
+			// 检查构建好的备注信息字符串是否不为 null 且长度大于 100
+			if (sBuilder.toString() != null && sBuilder.toString().length() > 100) {
+				// 如果长度大于 100，则截取前 100 个字符并添加省略号，然后设置为实体的备注信息
+				dicEntity
+						.setComments(sBuilder.toString().substring(0, 100) + "...");
+			} else {
+				// 如果长度不大于 100，则直接将构建好的字符串设置为实体的备注信息
+				dicEntity.setComments(sBuilder.toString());
+			}
+			// 调用数据访问层的方法，将更新后的实体信息保存到数据库中
+			dictionaryentityDao.editEntity(dicEntity);
+		}
+
+		// 设置 DictionaryEntityDaoInter 对象的方法
+		public void setdictionaryentityDao(
+				DictionaryEntityDaoInter dictionaryentityDao) {
+			// 将传入的 dictionaryentityDao 对象赋值给当前类的成员变量
+			this.dictionaryentityDao = dictionaryentityDao;
+		}
+
+		// 获取 DictionaryTypeDaoInter 对象的方法
+		public DictionaryTypeDaoInter getDictionarytypeDao() {
+			// 返回当前类的成员变量 dictionarytypeDao
+			return dictionarytypeDao;
+		}
+
+		// 设置 DictionaryTypeDaoInter 对象的方法
+		public void setDictionarytypeDao(DictionaryTypeDaoInter dictionarytypeDao) {
+			// 将传入的 dictionarytypeDao 对象赋值给当前类的成员变量
+			this.dictionarytypeDao = dictionarytypeDao;
+		}
+
+		// 重写接口中的 getDictionary 方法，用于根据键获取字典映射
+		@Override
+		public Map<String, String> getDictionary(String key) {
+			// 创建一个新的 HashMap 对象，用于存储字典信息
+			Map<String, String> dic = new HashMap<String, String>();
+			// 调用 loadDics 方法加载与键对应的 AloneDictionaryType 类型列表
+			for (AloneDictionaryType node : loadDics(key)) {
+				// 将类型的实体类型作为键，名称作为值，存入字典映射中
+				dic.put(node.getEntitytype(), node.getName());
+			}
+			// 返回存储好的字典映射
+			return dic;
+		}
+
+		// 私有方法，用于加载与键对应的 AloneDictionaryType 类型列表
+		private List<AloneDictionaryType> loadDics(String key) {
+			// 从缓存中获取与键对应的 AloneDictionaryType 类型列表
+			List<AloneDictionaryType> types = dicCache.get(key);
+			// 检查缓存中是否存在该键对应的列表，如果不存在则进行数据库查询操作
+			if (types == null) {
+				// 创建一个新的 ArrayList 对象，用于存储查询结果
+				types = new ArrayList<AloneDictionaryType>();
+				// 创建一个 DataQuery 对象，用于执行数据库查询操作
+				DataQuery query = DataQuery
+						.getInstance(1, "b.NAME,b.ENTITYTYPE",
+								"ALONE_DICTIONARY_ENTITY a LEFT JOIN  ALONE_DICTIONARY_TYPE b ON a.ID=b.ENTITY");
+				// 为查询添加规则，筛选出状态为 "1" 的记录
+				query.addRule(new DBRule("b.STATE", "1", "="));
+				// 为查询添加规则，筛选出实体索引等于传入键的记录
+				query.addRule(new DBRule("a.ENTITYINDEX", key, "="));
+				// 为查询添加排序规则，按照 SORT 字段升序排序
+				query.addSort(new DBSort("b.SORT", "asc"));
+				// 定义一个 DataResult 对象，用于存储查询结果
+				DataResult result = null;
+				try {
+					// 执行查询操作，并将结果存储到 result 中
+					result = query.search();
+				} catch (SQLException e) {
+					// 如果查询过程中出现 SQL 异常，则抛出运行时异常
+					throw new RuntimeException(e);
+				}
+				// 遍历查询结果列表
+				for (Map<String, Object> node : result.getResultList()) {
+					// 创建一个新的 AloneDictionaryType 对象
+					AloneDictionaryType type = new AloneDictionaryType();
+					// 将查询结果中的 B_ENTITYTYPE 字段值转换为字符串，并设置为类型的实体类型
+					type.setEntitytype(node.get("B_ENTITYTYPE").toString());
+					// 将查询结果中的 B_NAME 字段值转换为字符串，并设置为类型的名称
+					type.setName(node.get("B_NAME").toString());
+					// 将创建好的类型对象添加到类型列表中
+					types.add(type);
+				}
+				// 将查询得到的类型列表存入缓存中，键为传入的键
+				dicCache.put(key, types);
+			}
+			// 返回类型列表
+			return types;
+		}
+
+		// 重写接口中的 getDictionaryList 方法，用于根据键获取字典条目列表
+		@Override
+		public List<Entry<String, String>> getDictionaryList(String key) {
+			// 创建一个新的 ArrayList 对象，用于存储字典条目列表
+			List<Entry<String, String>> list = new ArrayList<Entry<String, String>>();
+			// 调用 loadDics 方法加载与键对应的 AloneDictionaryType 类型列表
+			for (AloneDictionaryType node : loadDics(key)) {
+				// 创建一个新的 SimpleEntry 对象，将类型的实体类型作为键，名称作为值
+				Entry<String, String> entry = new SimpleEntry<String, String>(node
+						.getEntitytype(), node.getName());
+				// 将创建好的条目对象添加到列表中
+				list.add(entry);
+			}
+			// 返回存储好的字典条目列表
+			return list;
+		}
+
+		// 重写接口中的 getDicKey 方法，用于根据字典 id 获取对应的键
+		@Override
+		public String getDicKey(String dicId) {
+			// 调用 getEntity 方法根据字典 id 获取对应的实体对象，并返回其实体索引
+			return getEntity(dicId).getEntityindex();
+		}

src/wcp-parameter/src/main/java/com/farm/parameter/service/impl/DictionaryTypeServiceImpl.java

@@ -0,0 +1,187 @@
+// 声明该类所在的包
+package com.farm.parameter.service.impl;
+
+// 导入列表接口，用于处理集合数据
+import java.util.List;
+// 导入 Vector 类，它是一个线程安全的动态数组，用于存储字典类型实体
+import java.util.Vector;
+
+// 导入用于资源注入的注解，可将 Spring 容器中的 bean 注入到该类的成员变量中
+import javax.annotation.Resource;
+
+// 导入 Spring 框架的注解，用于将该类标记为服务层组件，让 Spring 自动扫描并管理
+import org.springframework.stereotype.Service;
+// 导入 Spring 框架的事务管理注解，用于声明方法需要在事务环境中执行
+import org.springframework.transaction.annotation.Transactional;
+
+// 导入字典类型数据访问接口，用于与数据库进行交互操作
+import com.farm.parameter.dao.DictionaryTypeDaoInter;
+// 导入字典类型实体类，代表数据库中的字典类型表记录
+import com.farm.parameter.domain.AloneDictionaryType;
+// 导入登录用户实体类，用于获取当前登录用户的信息
+import com.farm.core.auth.domain.LoginUser;
+// 导入时间工具类，用于处理时间相关的操作，如获取当前时间
+import com.farm.core.time.TimeTool;
+// 导入字典实体服务接口，用于调用字典实体相关的业务逻辑
+import com.farm.parameter.service.DictionaryEntityServiceInter;
+// 导入字典类型服务接口，该类需要实现此接口中的方法
+import com.farm.parameter.service.DictionaryTypeServiceInter;
+
+// 使用 @Service 注解将该类标记为 Spring 服务组件，便于 Spring 进行管理
+@Service
+// 定义一个实现了 DictionaryTypeServiceInter 接口的服务类
+public class DictionaryTypeServiceImpl implements DictionaryTypeServiceInter {
+	// 使用 @Resource 注解注入 DictionaryTypeDaoInter 类型的 bean，用于与数据库交互
+	@Resource
+	private DictionaryTypeDaoInter dictionarytypeDao;
+	// 使用 @Resource 注解注入 DictionaryEntityServiceInter 类型的 bean，用于调用字典实体服务
+	@Resource
+	private DictionaryEntityServiceInter dicManager;
+	// 定义一个静态的线程安全列表，用于存储字典类型实体，初始化为空的 Vector
+	private static final List<AloneDictionaryType> DictionaryTypeList = new Vector<AloneDictionaryType>();
+
+	// 根据键获取配置值的方法，当前实现直接返回 null，可能需要后续完善
+	public String getConfigValue(String key) {
+		return null;
+	}
+
+	// 重写接口中的删除实体方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public void deleteEntity(String entity, LoginUser user) {
+		// 根据传入的实体 ID 从数据库中获取字典类型实体
+		AloneDictionaryType dictypeEntity = dictionarytypeDao.getEntity(entity);
+		// 调用数据访问层方法，根据实体的树编码删除相关实体
+		dictionarytypeDao.deleteEntityByTreecode(dictypeEntity.getId());
+		// 调用字典实体服务的方法，编辑关联字典实体的备注信息
+		dicManager.editComments(dictypeEntity.getEntity());
+		// 从缓存中移除关联字典实体的缓存数据
+		DictionaryEntityServiceImpl.dicCache.remove(dicManager.getDicKey(dictypeEntity.getEntity()));
+	}
+
+	// 重写接口中的编辑实体方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public AloneDictionaryType editEntity(AloneDictionaryType entity, LoginUser user) {
+		// 根据传入实体的 ID 从数据库中获取原字典类型实体
+		AloneDictionaryType entity2 = getEntity(entity.getId());
+		// 更新原实体的名称
+		entity2.setName(entity.getName());
+		// 更新原实体的实体类型
+		entity2.setEntitytype(entity.getEntitytype());
+		// 更新原实体的排序值
+		entity2.setSort(entity.getSort());
+		// 更新原实体的状态
+		entity2.setState(entity.getState());
+		// 更新原实体的备注信息
+		entity2.setComments(entity.getComments());
+		// 更新原实体的更新时间
+		entity2.setUtime(TimeTool.getTimeDate12());
+		// 更新原实体的修改用户名称
+		entity2.setMuser(user.getName());
+		// 调用数据访问层方法，更新字典类型实体到数据库
+		dictionarytypeDao.editEntity(entity2);
+		// 检查实体关联的字典 ID 是否为空，如果为空则抛出运行时异常
+		if (entity.getEntity() == null || entity.getEntity().equals("")) {
+			throw new RuntimeException("无法关联数据字典！");
+		}
+		// 调用字典实体服务的方法，编辑关联字典实体的备注信息
+		dicManager.editComments(entity.getEntity());
+		// 从缓存中移除关联字典实体的缓存数据
+		DictionaryEntityServiceImpl.dicCache.remove(dicManager.getDicKey(entity.getEntity()));
+		// 返回更新后的实体
+		return entity2;
+	}
+
+	// 获取所有字典类型实体的方法，当前实现直接返回 null，可能需要后续完善
+	public List<AloneDictionaryType> getAllEntity() {
+		return null;
+	}
+
+	// 获取所有字典类型实体数量的方法，当前实现直接返回 0，可能需要后续完善
+	public int getAllListNum() {
+		return 0;
+	}
+
+	// 重写接口中的获取实体方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public AloneDictionaryType getEntity(String id) {
+		// 如果传入的 ID 为 null，则直接返回 null
+		if (id == null) {
+			return null;
+		}
+		// 调用数据访问层方法，根据 ID 从数据库中获取字典类型实体
+		return dictionarytypeDao.getEntity(id);
+	}
+
+	// 重写接口中的插入实体方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public AloneDictionaryType insertEntity(AloneDictionaryType entity, LoginUser user) {
+		// 检查实体的父 ID 是否为空或长度为 0，如果是则将其设置为 "NONE"
+		if (entity.getParentid() == null || entity.getParentid().trim().length() <= 0) {
+			entity.setParentid("NONE");
+		}
+		// 设置实体的创建时间
+		entity.setCtime(TimeTool.getTimeDate12());
+		// 设置实体的创建用户 ID
+		entity.setCuser(user.getId());
+		// 设置实体的更新时间
+		entity.setUtime(TimeTool.getTimeDate12());
+		// 设置实体的修改用户 ID
+		entity.setMuser(user.getId());
+		// 设置实体的状态为 "1"
+		entity.setState("1");
+		// 调用数据访问层方法，将实体插入到数据库中
+		dictionarytypeDao.insertEntity(entity);
+
+		// 根据实体的父 ID 获取父实体
+		AloneDictionaryType fatherEntity = getEntity(entity.getParentid());
+		// 如果父实体为空，则将实体的树编码设置为其自身的 ID
+		if (fatherEntity == null) {
+			entity.setTreecode(entity.getId());
+		} else {
+			// 否则，将实体的树编码设置为父实体的树编码加上自身的 ID
+			entity.setTreecode(fatherEntity.getTreecode() + entity.getId());
+		}
+		// 调用数据访问层方法，更新实体的树编码到数据库
+		dictionarytypeDao.editEntity(entity);
+
+		// 检查实体关联的字典 ID 是否为空，如果为空则抛出运行时异常
+		if (entity.getEntity() == null || entity.getEntity().equals("")) {
+			throw new RuntimeException("无法关联数据字典！");
+		}
+		// 调用字典实体服务的方法，编辑关联字典实体的备注信息
+		dicManager.editComments(entity.getEntity());
+		// 从缓存中移除关联字典实体的缓存数据
+		DictionaryEntityServiceImpl.dicCache.remove(dicManager.getDicKey(entity.getEntity()));
+		// 返回插入的实体
+		return entity;
+	}
+
+	// 获取静态字典类型列表的方法
+	public static List<AloneDictionaryType> getdictionarytypeList() {
+		return DictionaryTypeList;
+	}
+
+	// 获取字典类型数据访问对象的方法
+	public DictionaryTypeDaoInter getdictionarytypeDao() {
+		return dictionarytypeDao;
+	}
+
+	// 设置字典类型数据访问对象的方法
+	public void setdictionarytypeDao(DictionaryTypeDaoInter dictionarytypeDao) {
+		this.dictionarytypeDao = dictionarytypeDao;
+	}
+
+	// 获取字典实体服务对象的方法
+	public DictionaryEntityServiceInter getDicManager() {
+		return dicManager;
+	}
+
+	// 设置字典实体服务对象的方法
+	public void setDicManager(DictionaryEntityServiceInter dicManager) {
+		this.dicManager = dicManager;
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/impl/ParameterServiceImpl.java

@@ -0,0 +1,430 @@
+// 声明该类所属的包
+package com.farm.parameter.service.impl;
+
+// 导入 SQL 异常类，用于处理数据库操作中可能出现的 SQL 异常
+import java.sql.SQLException;
+// 导入 ArrayList 类，用于创建动态数组，存储数据
+import java.util.ArrayList;
+// 导入 HashMap 类，用于创建键值对映射，存储参数缓存
+import java.util.HashMap;
+// 导入 List 接口，用于定义列表类型的变量
+import java.util.List;
+// 导入 Map 接口，用于定义映射类型的变量
+import java.util.Map;
+
+// 导入资源注入注解，用于将 Spring 容器中的 Bean 注入到该类的成员变量中
+import javax.annotation.Resource;
+
+// 导入 Spring 服务注解，将该类标记为服务层组件，由 Spring 管理
+import org.springframework.stereotype.Service;
+// 导入 Spring 事务注解，用于声明方法在事务环境中执行
+import org.springframework.transaction.annotation.Transactional;
+
+// 导入 Aloneparameterlocal 数据访问接口，用于与 Aloneparameterlocal 表进行交互
+import com.farm.parameter.dao.AloneparameterlocalDaoInter;
+// 导入 Parameter 数据访问接口，用于与 Parameter 表进行交互
+import com.farm.parameter.dao.ParameterDaoInter;
+// 导入 AloneParameter 实体类，代表参数实体
+import com.farm.parameter.domain.AloneParameter;
+// 导入 Aloneparameterlocal 实体类，代表用户个性化参数实体
+import com.farm.parameter.domain.Aloneparameterlocal;
+// 导入自定义的键存在异常类，用于处理参数键重复的情况
+import com.farm.parameter.exception.KeyExistException;
+// 导入登录用户实体类，用于获取当前登录用户的信息
+import com.farm.core.auth.domain.LoginUser;
+// 导入数据库排序类，用于设置查询结果的排序规则
+import com.farm.core.sql.query.DBSort;
+// 导入数据查询类，用于构建和执行数据库查询
+import com.farm.core.sql.query.DataQuery;
+// 导入数据结果类，用于处理查询返回的结果
+import com.farm.core.sql.result.DataResult;
+// 导入时间工具类，用于处理时间相关的操作，如获取当前时间
+import com.farm.core.time.TimeTool;
+// 导入参数服务接口，该类需要实现此接口中的方法
+import com.farm.parameter.service.ParameterServiceInter;
+
+// 使用 @Service 注解将该类标记为 Spring 服务组件
+@Service
+// 定义 ParameterServiceImpl 类，实现 ParameterServiceInter 接口
+public class ParameterServiceImpl implements ParameterServiceInter {
+	// 使用 @Resource 注解注入 ParameterDaoInter 类型的 Bean
+	@Resource
+	private ParameterDaoInter parameterDao;
+	// 使用 @Resource 注解注入 AloneparameterlocalDaoInter 类型的 Bean
+	@Resource
+	private AloneparameterlocalDaoInter aloneparameterlocalDao;
+	// 定义一个静态的参数值缓存，使用 HashMap 存储键值对
+	private static final Map<String, String> parameterCache = new HashMap<String, String>();
+	// 定义一个静态的参数实体缓存，使用 HashMap 存储键和对应的 AloneParameter 实体
+	private static final Map<String, AloneParameter> parameterEntityCache = new HashMap<String, AloneParameter>();
+
+	// 初始化配置的方法，当前返回 false，可能需要后续实现具体逻辑
+	public boolean initConfig() {
+		return false;
+	}
+
+	// 刷新缓存的方法，清空参数实体缓存和参数值缓存，并返回 true 表示刷新成功
+	public boolean refreshCache() {
+		parameterEntityCache.clear();
+		parameterCache.clear();
+		return true;
+	}
+
+	// 重写删除实体的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public void deleteEntity(String entity, LoginUser user) {
+		// 根据实体 ID 获取实体对象，并调用数据访问层的删除方法删除该实体
+		parameterDao.deleteEntity(parameterDao.getEntity(entity));
+	}
+
+	// 重写插入实体的方法，使用 @Transactional 注解确保操作在事务中执行，可能抛出 KeyExistException 异常
+	@Override
+	@Transactional
+	public AloneParameter insertEntity(AloneParameter entity, String domain, LoginUser aloneUser)
+			throws KeyExistException {
+		// 检查参数键是否重复，如果重复则抛出运行时异常
+		if (isRepeatKey(entity.getPkey())) {
+			throw new RuntimeException("参数键：" + entity.getPkey() + "，已存在！");
+		}
+		// 如果参数类型为“文本”，则将枚举规则置为空
+		if (entity.getVtype().equals("1")) {
+			entity.setRules("");
+		}
+		// 设置实体的创建时间和更新时间为当前时间
+		entity.setCtime(TimeTool.getTimeDate12());
+		entity.setUtime(TimeTool.getTimeDate12());
+		// 设置实体的创建用户和修改用户为当前登录用户的 ID
+		entity.setCuser(aloneUser.getId());
+		entity.setMuser(aloneUser.getId());
+		// 设置实体的状态为“1”，表示启用
+		entity.setState("1");
+		// 调用数据访问层的插入方法插入实体，并返回插入后的实体
+		parameterDao.insertEntity(entity);
+		return entity;
+	}
+
+	// 重写编辑实体的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public AloneParameter editEntity(AloneParameter entity, LoginUser aloneUser) {
+		// 根据实体 ID 获取原实体对象
+		AloneParameter entity2 = getEntity(entity.getId());
+		// 检查参数键是否被修改且新键已存在，如果是则抛出运行时异常
+		if (!entity2.getPkey().equals(entity.getPkey()) && isRepeatKey(entity.getPkey())) {
+			throw new RuntimeException("参数键：" + entity.getPkey() + "，已存在！");
+		}
+		// 如果参数类型为“文本”，则将枚举规则置为空
+		if (entity.getVtype().equals("1")) {
+			entity.setRules("");
+		}
+		// 更新原实体的更新时间为当前时间
+		entity2.setUtime(TimeTool.getTimeDate12());
+		// 更新原实体的修改用户为当前登录用户的 ID
+		entity2.setMuser(aloneUser.getId());
+		// 更新原实体的名称
+		entity2.setName(entity.getName());
+		// 更新原实体的参数键
+		entity2.setPkey(entity.getPkey());
+		// 更新原实体的参数值
+		entity2.setPvalue(entity.getPvalue());
+		// 更新原实体的枚举规则
+		entity2.setRules(entity.getRules());
+		// 更新原实体的域
+		entity2.setDomain(entity.getDomain());
+		// 更新原实体是否允许用户自定义的标志
+		entity2.setUserable(entity.getUserable());
+		// 更新原实体的备注信息
+		entity2.setComments(entity.getComments());
+		// 更新原实体的参数类型
+		entity2.setVtype(entity.getVtype());
+		// 调用数据访问层的编辑方法更新实体，并返回更新后的实体
+		parameterDao.editEntity(entity2);
+		return entity2;
+	}
+
+	// 检查参数键是否重复的方法，排除指定 ID 的参数
+	public boolean isRepeatKey(String paramKey, String excludeParamId) {
+		// 定义一个列表用于存储查询到的参数列表
+		List<AloneParameter> paramList = null;
+		// 如果排除的参数 ID 为空，则直接根据参数键查询参数列表
+		if (excludeParamId == null || excludeParamId.equals("")) {
+			paramList = parameterDao.findListByKey(paramKey.trim());
+		} else {
+			// 否则，根据参数键和排除的参数 ID 查询参数列表
+			paramList = parameterDao.findListByKeyAndExcludeParamId(paramKey.trim(), excludeParamId);
+		}
+		// 如果查询到的参数列表不为空，则表示参数键重复，返回 true
+		return paramList.size() > 0;
+	}
+
+	// 检查参数键是否重复的方法，不排除任何参数
+	public boolean isRepeatKey(String paramKey) {
+		// 调用带排除参数 ID 的方法，排除参数 ID 为 null
+		return isRepeatKey(paramKey, null);
+	}
+
+	// 重写获取实体的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public AloneParameter getEntity(String id) {
+		// 如果 ID 为 null，则返回 null
+		if (id == null) {
+			return null;
+		}
+		// 调用数据访问层的方法根据 ID 获取实体并返回
+		return parameterDao.getEntity(id);
+	}
+
+	// 获取 ParameterDaoInter 对象的方法
+	public ParameterDaoInter getParameterDao() {
+		return parameterDao;
+	}
+
+	// 设置 ParameterDaoInter 对象的方法
+	public void setParameterDao(ParameterDaoInter parameterDao) {
+		this.parameterDao = parameterDao;
+	}
+
+	// 获取 AloneparameterlocalDaoInter 对象的方法
+	public AloneparameterlocalDaoInter getAloneparameterlocalDao() {
+		return aloneparameterlocalDao;
+	}
+
+	// 设置 AloneparameterlocalDaoInter 对象的方法
+	public void setAloneparameterlocalDao(AloneparameterlocalDaoInter aloneparameterlocalDao) {
+		this.aloneparameterlocalDao = aloneparameterlocalDao;
+	}
+
+	// 重写获取转换后的参数列表的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public List<Map<String, Object>> getTransParamList(String domainType) {
+		// 定义一个字符串变量，用于存储转换后的域类型
+		String type = "";
+		// 根据传入的域类型进行转换
+		if (domainType.equals("1")) {
+			type = "alone";
+		} else if (domainType.equals("2")) {
+			type = "app";
+		} else if (domainType.equals("3")) {
+			type = "ccs";
+		}
+		// 调用数据访问层的方法根据转换后的域类型获取参数列表
+		List<Map<String, Object>> list = parameterDao.getListByDomainType(type);
+		// 遍历参数列表
+		for (Map<String, Object> map : list) {
+			// 如果参数类型为枚举值
+			if (map.get("VTYPE").equals('2')) {
+				// 创建一个二维列表，用于存储枚举值的键值对
+				ArrayList<List<String>> enumList = new ArrayList<List<String>>();
+				// 将枚举规则按逗号分割成多个键值对字符串
+				for (String enumStr : (map.get("RULES") + "").split(",")) {
+					// 创建一个列表，用于存储单个键值对
+					ArrayList<String> kvList = new ArrayList<String>();
+					// 将单个键值对字符串按冒号分割成键和值
+					for (String kvStr : enumStr.split(":")) {
+						kvList.add(kvStr);
+					}
+					// 将单个键值对列表添加到二维列表中
+					enumList.add(kvList);
+				}
+				// 将二维列表添加到参数映射中，键为 "ENUMVALUE"
+				map.put("ENUMVALUE", enumList);
+			}
+		}
+		// 返回处理后的参数列表
+		return list;
+	}
+
+	// 重写根据参数键查找实体的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public AloneParameter findEntityByKey(String paramKey) {
+		// 去除参数键两端的空格
+		paramKey = paramKey.trim();
+		// 从参数实体缓存中获取参数实体
+		AloneParameter parameter = parameterEntityCache.get(paramKey);
+		// 如果缓存中不存在该参数实体
+		if (!parameterEntityCache.containsKey(paramKey.trim())) {
+			// 调用数据访问层的方法根据参数键获取参数实体
+			parameter = parameterDao.getEntityByKey(paramKey.trim());
+			// 将获取到的参数实体存入参数实体缓存中
+			parameterEntityCache.put(paramKey.trim(), parameter);
+		}
+		// 返回参数实体
+		return parameter;
+	}
+
+	// 重写设置参数值的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public void setValue(String key, String pValue, LoginUser aloneUser) {
+		// 根据参数键查找参数实体
+		AloneParameter entity = findEntityByKey(key);
+		// 更新参数实体的更新时间为当前时间
+		entity.setUtime(TimeTool.getTimeDate12());
+		// 更新参数实体的修改用户为当前登录用户的 ID
+		entity.setMuser(aloneUser.getId());
+		// 更新参数实体的参数值
+		entity.setPvalue(pValue);
+		// 调用数据访问层的方法更新参数实体
+		parameterDao.editEntity(entity);
+		// 清空参数值缓存
+		parameterCache.clear();
+	}
+
+	// 重写获取所有参数的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public List<Map<String, Object>> getAllParameters() {
+		// 初始化数据查询对象，设置查询的表和要查询的字段
+		DataQuery query = DataQuery.init(
+				null,
+				"Alone_Parameter a",
+				"id,domain,name,pkey,pvalue,vtype,comments,rules");
+		// 设置查询结果按参数名称升序排序
+		query.addSort(new DBSort("a.name", "asc"));
+		// 设置每页显示的记录数为 200
+		query.setPagesize(200);
+		// 定义一个数据结果对象，用于存储查询结果
+		DataResult result = null;
+		try {
+			// 执行查询操作，将结果存储到数据结果对象中
+			result = query.search();
+		} catch (SQLException e) {
+			// 如果查询过程中出现 SQL 异常，抛出运行时异常
+			throw new RuntimeException(e);
+		}
+		// 返回查询结果列表
+		return result.getResultList();
+	}
+
+	// 重写获取用户参数的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public List<Map<String, Object>> getUserParameters(String userid) {
+		// 初始化数据查询对象，设置查询的表连接和要查询的字段
+		DataQuery query = DataQuery.init(
+				null,
+				"Alone_Parameter a left join ALONE_PARAMETER_LOCAL b on b.PARAMETERID=a.id",
+				"a.id as id,a.domain as domain,a.name as name,a.pkey as pkey,a.pvalue as pvalue,a.vtype as vtype,a.comments as comments,a.rules as rules,b.pvalue as uservalue");
+		// 设置查询结果按参数名称升序排序
+		query.addSort(new DBSort("a.name", "asc"));
+		// 设置每页显示的记录数为 200
+		query.setPagesize(200);
+		// 添加 SQL 规则，筛选出允许用户自定义的参数
+		query.addSqlRule(" and USERABLE='1'");
+		// 定义一个数据结果对象，用于存储查询结果
+		DataResult result = null;
+		try {
+			// 执行查询操作，将结果存储到数据结果对象中
+			result = query.search();
+		} catch (SQLException e) {
+			// 如果查询过程中出现 SQL 异常，抛出运行时异常
+			throw new RuntimeException(e);
+		}
+		// 遍历查询结果列表
+		for (Map<String, Object> node : result.getResultList()) {
+			// 如果用户个性化参数值不为空且长度大于 0
+			if (node.get("USERVALUE") != null && node.get("USERVALUE").toString().trim().length() > 0) {
+				// 将参数值更新为用户个性化参数值
+				node.put("PVALUE", node.get("USERVALUE"));
+			}
+		}
+		// 返回处理后的查询结果列表
+		return result.getResultList();
+	}
+
+	// 重写设置用户参数值的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public void setUserValue(String key, String pValue, LoginUser aloneUser) {
+		// 根据参数键查找参数实体
+		AloneParameter entity = findEntityByKey(key);
+		// 如果参数实体不存在，抛出运行时异常
+		if (entity == null) {
+			throw new RuntimeException("参数不存在!");
+		}
+		// 如果参数不允许用户自定义，抛出运行时异常
+		if (entity.getUserable().equals("0")) {
+			throw new RuntimeException("该参数不允许用户自定义！");
+		}
+		// 根据用户 ID 和参数实体 ID 获取用户个性化参数实体
+		Aloneparameterlocal localPara = aloneparameterlocalDao.getEntityByUser(aloneUser.getId(), entity.getId());
+		// 如果用户个性化参数实体不存在
+		if (localPara == null) {
+			// 创建一个新的用户个性化参数实体
+			localPara = new Aloneparameterlocal();
+			// 设置用户个性化参数实体的用户 ID
+			localPara.setEuser(aloneUser.getId());
+			// 设置用户个性化参数实体的参数 ID
+			localPara.setParameterid(entity.getId());
+			// 设置用户个性化参数实体的参数值
+			localPara.setPvalue(pValue);
+			// 调用数据访问层的方法插入用户个性化参数实体
+			aloneparameterlocalDao.insertEntity(localPara);
+		} else {
+			// 如果用户个性化参数实体存在，更新其参数值
+			localPara.setPvalue(pValue);
+			// 调用数据访问层的方法更新用户个性化参数实体
+			aloneparameterlocalDao.editEntity(localPara);
+		}
+		// 清空参数值缓存
+		parameterCache.clear();
+	}
+
+	// 重写获取参数值的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public String getValue(String key) {
+		// 如果参数值缓存中包含该参数键
+		if (parameterCache.containsKey(key)) {
+			// 从缓存中获取参数值并返回
+			return parameterCache.get(key);
+		} else {
+			// 根据参数键查找参数实体
+			AloneParameter entity = findEntityByKey(key);
+			// 如果参数实体不存在
+			if (entity == null) {
+				// 将参数键和 null 存入参数值缓存中
+				parameterCache.put(key, null);
+				// 返回 null
+				return null;
+			}
+			// 如果参数值缓存的大小超过 1000
+			if (parameterCache.size() > 1000) {
+				// 清空参数值缓存
+				parameterCache.clear();
+			}
+			// 将参数键和参数值存入参数值缓存中
+			parameterCache.put(key, entity.getPvalue());
+			// 返回参数值
+			return entity.getPvalue();
+		}
+	}
+
+	// 重写根据用户 ID 获取参数值的方法，使用 @Transactional 注解确保操作在事务中执行
+	@Override
+	@Transactional
+	public String getValue(String key, String userId) {
+		// 根据参数键查找参数实体
+		AloneParameter entity = findEntityByKey(key);
+		// 如果参数实体不存在，返回 null
+		if (entity == null) {
+			return null;
+		}
+		// 如果参数允许用户自定义
+		if (entity.getUserable().equals("1")) {
+			// 根据用户 ID 和参数实体 ID 获取用户个性化参数实体
+			Aloneparameterlocal localPara = aloneparameterlocalDao.getEntityByUser(userId, entity.getId());
+			// 如果用户个性化参数实体存在
+			if (localPara != null) {
+				// 返回用户个性化参数值
+				return localPara.getPvalue();
+			}
+		}
+		// 如果没有用户个性化参数，调用无用户 ID 的获取参数值方法
+		return getValue(key);
+	}
+}

src/wcp-parameter/src/main/java/com/farm/parameter/service/impl/PropertiesFileService.java

@@ -0,0 +1,104 @@
+// 声明该类所属的包
+package com.farm.parameter.service.impl;
+
+// 导入 ArrayList 类，用于创建动态数组来存储键值对条目
+import java.util.ArrayList;
+// 导入 Enumeration 接口，用于遍历资源包中的键
+import java.util.Enumeration;
+// 导入 HashSet 类，用于创建一个无序且不重复的集合来存储资源包
+import java.util.HashSet;
+// 导入 List 接口，用于定义列表类型的变量
+import java.util.List;
+// 导入 MissingResourceException 异常类，用于捕获找不到资源的异常
+import java.util.MissingResourceException;
+// 导入 ResourceBundle 类，用于读取属性文件
+import java.util.ResourceBundle;
+// 导入 Set 接口，用于定义集合类型的变量
+import java.util.Set;
+// 导入用于创建简单键值对条目的类
+import java.util.AbstractMap.SimpleEntry;
+// 导入用于遍历映射条目的接口
+import java.util.Map.Entry;
+
+// 导入 Apache Log4j 的 Logger 类，用于记录日志
+import org.apache.log4j.Logger;
+// 导入 Spring 的 Service 注解，用于将该类标记为服务层组件
+import org.springframework.stereotype.Service;
+
+// 导入自定义的参数控制器类，用于获取日志记录器的相关信息
+import com.farm.parameter.controller.ParameterController;
+
+// 使用 @Service 注解将该类标记为 Spring 服务组件
+@Service
+// 定义 PropertiesFileService 类，用于处理属性文件相关的操作
+public class PropertiesFileService {
+	// 定义一个静态的 Set 集合，用于存储加载的资源包，使用 HashSet 实现
+	private static Set<ResourceBundle> constant = new HashSet<ResourceBundle>();
+	// 定义一个静态的 Logger 对象，用于记录日志，日志记录器关联到 ParameterController 类
+	private static final Logger log = Logger
+			.getLogger(ParameterController.class);
+
+	/**
+	 * 注册配置文件的方法
+	 *
+	 * @param fileName 配置文件的名称，例如 "config" 对应 "config.properties"
+	 * @return 如果成功将资源包添加到集合中则返回 true，否则返回 false
+	 */
+	public static boolean registConstant(String fileName) {
+		// 记录日志，提示正在注册的配置文件名称
+		log.info("注册配置文件" + fileName + ".properties");
+		// 加载指定名称的资源包，并将其添加到 constant 集合中，返回添加结果
+		return constant.add(ResourceBundle.getBundle(fileName));
+	}
+
+	// 获取所有键值对条目的方法
+	public static List<Entry<String, String>> getEntrys() {
+		// 创建一个新的 ArrayList，用于存储键值对条目
+		List<Entry<String, String>> list = new ArrayList<Entry<String, String>>();
+		// 遍历 constant 集合中的每个资源包
+		for (ResourceBundle node : constant) {
+			// 获取当前资源包中的所有键的枚举
+			Enumeration<String> enums = node.getKeys();
+			// 遍历枚举中的每个键
+			while (enums.hasMoreElements()) {
+				// 获取当前键
+				String key = enums.nextElement();
+				// 创建一个键值对条目，键为当前键，值为从资源包中获取的对应值
+				Entry<String, String> entry = new SimpleEntry<String, String>(
+						key, node.getString(key));
+				// 将键值对条目添加到 list 中
+				list.add(entry);
+			}
+		}
+		// 返回存储了所有键值对条目的 list
+		return list;
+	}
+
+	// 根据键获取对应值的方法
+	public static String getValue(String key) {
+		// 遍历 constant 集合中的每个资源包
+		for (ResourceBundle node : constant) {
+			// 调用 getString 方法从当前资源包中获取键对应的值
+			String value = getString(key, node);
+			// 如果获取到的值不为 null，则返回该值
+			if (value != null) {
+				return value;
+			}
+		}
+		// 如果在所有资源包中都未找到对应的值，则返回 null
+		return null;
+	}
+
+	// 从指定资源包中获取键对应值的私有方法
+	private static String getString(String key, ResourceBundle bundle) {
+		try {
+			// 从资源包中获取指定键对应的值
+			String messager = bundle.getString(key);
+			// 返回获取到的值
+			return messager;
+		} catch (MissingResourceException e) {
+			// 如果找不到指定键的资源，则返回 null
+			return null;
+		}
+	}
+}