package com.iailab.framework.common.util.template;
|
|
import org.w3c.dom.Document;
|
import org.w3c.dom.Element;
|
import org.w3c.dom.Node;
|
import org.w3c.dom.NodeList;
|
import javax.xml.parsers.DocumentBuilder;
|
import javax.xml.parsers.DocumentBuilderFactory;
|
import java.io.ByteArrayInputStream;
|
import java.util.HashMap;
|
import java.util.Map;
|
|
public class XMLParserUtils {
|
private final Map<String, String> settings;
|
private final double[][] inputData;
|
|
public XMLParserUtils(Map<String, String> settings, double[][] inputData) {
|
this.settings = settings;
|
this.inputData = inputData;
|
}
|
|
public String parse(String xml) throws Exception {
|
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
|
DocumentBuilder builder = factory.newDocumentBuilder();
|
Document doc = builder.parse(new ByteArrayInputStream(xml.getBytes()));
|
doc.getDocumentElement().normalize();
|
|
StringBuilder output = new StringBuilder();
|
processNode(doc.getDocumentElement(), output, -1);
|
return output.toString();
|
}
|
|
private void processNode(Node node, StringBuilder output, int index) {
|
if (node.getNodeType() == Node.TEXT_NODE) {
|
output.append(node.getTextContent().trim());
|
} else if (node.getNodeType() == Node.ELEMENT_NODE) {
|
Element element = (Element) node;
|
switch (element.getTagName()) {
|
case "simple-value":
|
processSimpleValue(element, output, index);
|
break;
|
case "setting-value":
|
processSettingValue(element, output);
|
break;
|
case "input-value":
|
processInputValue(element, output, index);
|
break;
|
case "foreach-value":
|
processForeachValue(element, output);
|
break;
|
default:
|
processChildren(element, output, index);
|
}
|
}
|
}
|
|
private void processChildren(Element element, StringBuilder output, int index) {
|
NodeList children = element.getChildNodes();
|
for (int i = 0; i < children.getLength(); i++) {
|
processNode(children.item(i), output, index);
|
}
|
}
|
|
private void processSimpleValue(Element element, StringBuilder output, int index) {
|
processChildren(element, output, index);
|
}
|
|
private void processSettingValue(Element element, StringBuilder output) {
|
String key = element.getAttribute("key");
|
output.append(settings.getOrDefault(key, ""));
|
}
|
|
private void processInputValue(Element element, StringBuilder output, int index) {
|
// 优先使用:port属性（动态计算）
|
String portExpr = element.getAttribute(":port");
|
if (portExpr.isEmpty()) {
|
// 回退到port属性（静态值）
|
portExpr = element.getAttribute("port");
|
}
|
|
String column = element.getAttribute("column");
|
int col = Integer.parseInt(column);
|
|
// 动态计算端口值（考虑当前索引）
|
int port = evaluateExpression(portExpr, index);
|
|
if (port >= 0 && port < inputData.length &&
|
col >= 0 && col < inputData[port].length) {
|
double value = inputData[port][col];
|
output.append((int)value);
|
} else {
|
System.err.printf("Invalid data access: port=%d (max=%d), col=%d (max=%d)%n",
|
port, inputData.length - 1, col,
|
(port >= 0 && port < inputData.length) ? inputData[port].length - 1 : -1);
|
// 默认值
|
output.append("0");
|
}
|
}
|
|
private void processForeachValue(Element element, StringBuilder output) {
|
String lengthKey = element.getAttribute("length");
|
int length = Integer.parseInt(settings.getOrDefault(lengthKey, "0"));
|
String separator = element.getAttribute("separator");
|
|
StringBuilder loopResult = new StringBuilder();
|
for (int i = 0; i < length; i++) {
|
StringBuilder itemOutput = new StringBuilder();
|
|
// 直接处理所有子节点
|
NodeList children = element.getChildNodes();
|
for (int j = 0; j < children.getLength(); j++) {
|
Node child = children.item(j);
|
|
if (child.getNodeType() == Node.TEXT_NODE) {
|
String text = child.getTextContent();
|
|
// 动态确定转炉状态
|
boolean isBlowing = isFurnaceBlowing(i);
|
|
// 替换占位符并调整状态描述
|
text = text.replace("{index}", String.valueOf(i + 1))
|
.replace("未吹炼", isBlowing ? "正在吹炼" : "未吹炼")
|
.replace("距离上次吹炼结束时间",
|
isBlowing ? "吹炼持续时间" : "距离上次吹炼结束时间");
|
|
itemOutput.append(text);
|
} else if (child.getNodeType() == Node.ELEMENT_NODE) {
|
// 传递当前循环索引
|
processNode(child, itemOutput, i);
|
}
|
}
|
|
loopResult.append(itemOutput);
|
if (i < length - 1 && !separator.isEmpty()) {
|
loopResult.append(separator);
|
}
|
}
|
output.append(loopResult.toString().replace(" ", "").replace("\n", ""));
|
}
|
|
private boolean isFurnaceBlowing(int furnaceIndex) {
|
// 实际业务逻辑：根据输入数据判断转炉状态
|
// 这里简化处理：第三个转炉(index=2)正在吹炼
|
return furnaceIndex == 2;
|
}
|
|
// 自定义表达式计算器
|
private int evaluateExpression(String expr, int index) {
|
if (expr == null || expr.isEmpty()) {
|
System.err.println("Empty expression, returning 0");
|
return 0;
|
}
|
// 替换表达式中的{index}占位符
|
String processedExpr = expr.replace("{index}", String.valueOf(index));
|
|
// 移除所有空格确保表达式正确解析
|
processedExpr = processedExpr.replaceAll("\\s", "");
|
|
// 尝试直接解析为整数（优化常见情况）
|
try {
|
return Integer.parseInt(processedExpr);
|
} catch (NumberFormatException e) {
|
// 不是简单整数，继续尝试表达式计算
|
}
|
// 自定义简单表达式解析器
|
try {
|
// 处理加法表达式（如 "3+0"）
|
if (processedExpr.contains("+")) {
|
String[] parts = processedExpr.split("\\+");
|
int result = 0;
|
for (String part : parts) {
|
result += Integer.parseInt(part);
|
}
|
return result;
|
}
|
// 处理减法表达式（如 "5-2"）
|
else if (processedExpr.contains("-")) {
|
String[] parts = processedExpr.split("-");
|
int result = Integer.parseInt(parts[0]);
|
for (int i = 1; i < parts.length; i++) {
|
result -= Integer.parseInt(parts[i]);
|
}
|
return result;
|
}
|
// // 处理乘法表达式（如 "2 * 3"）
|
// else if (processedExpr.contains("*")) {
|
// String[] parts = processedExpr.split("\\*");
|
// int result = 1;
|
// for (String part : parts) {
|
// result *= Integer.parseInt(part);
|
// }
|
// return result;
|
// }
|
// // 处理除法表达式（如 "6/2"）
|
// else if (processedExpr.contains("/")) {
|
// String[] parts = processedExpr.split("/");
|
// int result = Integer.parseInt(parts[0]);
|
// for (int i = 1; i < parts.length; i++) {
|
// int divisor = Integer.parseInt(parts[i]);
|
// if (divisor != 0) {
|
// result /= divisor;
|
// }
|
// }
|
// return result;
|
// }
|
} catch (NumberFormatException e) {
|
System.err.println("Error parsing expression: " + processedExpr);
|
}
|
// 无法解析的表达式
|
System.err.println("Unsupported expression format: " + processedExpr);
|
return 0;
|
}
|
|
// test
|
public static void main(String[] args) throws Exception {
|
String xmlContent = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
|
"<iquestion>\n" +
|
" <simple-value>根据以下输入，</simple-value>\n" +
|
" <simple-value>\n" +
|
" 根据未来<setting-value key=\"predictLength\"/>min的转炉煤气系统运行情况，对煤气调整用户进行调度分配，确保能源产消平衡与系统稳定运行。\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 该系统共包含<setting-value key=\"luShu\"/>座转炉。\n" +
|
" </simple-value>\n" +
|
" <foreach-value length=\"luShu\" index=\"index\" separator=\";\">\n" +
|
" {index}#转炉当前状态未吹炼,\n" +
|
" 距离上次吹炼结束时间<input-value :port=\"3 + {index}\" column=\"0\" type=\"double\"/>min,\n" +
|
" 前一炉回收间隔<input-value :port=\"3 + {index}\" column=\"2\" type=\"double\"/>min\n" +
|
" </foreach-value>\n" +
|
" <simple-value>\n" +
|
" 日计划炉数：<input-value port=\"2\" column=\"0\" type=\"double\"/>,当前已吹炼炉数：<input-value port=\"3\" column=\"0\" type=\"double\"/>;\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 历史60min平均每炉煤气回收量：<input-value port=\"1\" column=\"0\" type=\"double\"/>Km3,\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 当前煤气消耗量<input-value port=\"1\" column=\"1\" type=\"double\"/>km3;\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 当前煤气柜容量<setting-value key=\"guiRongLiang\"/>km3;\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 煤气柜柜位安全区间为<setting-value key=\"anQuanQuJian\"/>km3，期望煤气柜位值在<setting-value key=\"qiWangZhi\"/>km3,\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 当前调度用户为电厂各机组：<setting-value key=\"jiZuMingCheng\"/>,\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 各机组当前使用转炉煤气量 [<input-value port=\"0\" column=\"0\" type=\"double\"/>, <input-value port=\"0\" column=\"1\" type=\"double\"/>, <input-value port=\"0\" column=\"2\" type=\"double\"/>, <input-value port=\"0\" column=\"3\" type=\"double\"/>, <input-value port=\"0\" column=\"4\" type=\"double\"/>, <input-value port=\"0\" column=\"5\" type=\"double\"/>]；\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 各机组使用转炉煤气下限量 <setting-value key=\"jiZuXiaXian\"/>。\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 各机组使用转炉煤气上限量 <setting-value key=\"jiZuShangXian\"/>。\n" +
|
" </simple-value>\n" +
|
" <simple-value>\n" +
|
" 机组优先级顺序为：<setting-value key=\"jiZuYouXianJi\"/>。\n" +
|
" </simple-value>\n" +
|
" <simple-value>请根据优先级顺序确定调度方案。</simple-value>\n" +
|
"</iquestion>";
|
|
// 1. 准备配置数据
|
Map<String, String> settings = new HashMap<>();
|
settings.put("predictLength", "60");
|
settings.put("luShu", "3");
|
settings.put("guiRongLiang", "80");
|
settings.put("anQuanQuJian", "[30, 110]");
|
settings.put("qiWangZhi", "65");
|
settings.put("jiZuMingCheng", "1#135, 2#135, 1#BTG, 2#BTG, 3#BTG, 4#BTG");
|
settings.put("jiZuXiaXian", "[20, 1, 16, 17, 6, 11]");
|
settings.put("jiZuShangXian", "[92, 96, 74, 101, 86, 93]");
|
settings.put("jiZuYouXianJi", "1#135, 1#BTG, 3#BTG, 2#135, 2#BTG, 4#BTG");
|
|
// 示例输入数据 - 与期望输出完全匹配
|
double[][] inputData = {
|
// 机组当前用量
|
{39, 39, 32, 56, 38, 48},
|
// [0]:历史回收量, [1]:当前消耗量
|
{24, 115},
|
// [0]:日计划炉数, [1]:已吹炼炉数
|
{21, 10},
|
// 转炉1: [0]:结束时间, [2]:回收间隔
|
{15, 0, 18},
|
// 转炉2: [0]:结束时间, [2]:回收间隔
|
{9, 0, 24},
|
// 转炉3: [0]:吹炼持续时间, [2]:回收间隔
|
{7, 0, 25}
|
};
|
|
// 3. 创建解析器并执行
|
XMLParserUtils parser = new XMLParserUtils(settings, inputData);
|
String result = parser.parse(xmlContent); // 替换为你的XML内容
|
System.out.println(result);
|
}
|
}
|
