package com.estate.expert.admin.io.processor.impl.matrix;
|
|
import com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix;
|
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
|
import com.estate.expert.admin.enums.BizResultCode;
|
import com.estate.expert.admin.io.processor.DataProcessorBase;
|
import com.estate.expert.admin.utils.tree.TreeNode;
|
import com.estate.expert.admin.utils.tree.TreeRoot;
|
import lombok.AllArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.poi.ss.usermodel.*;
|
|
import java.io.IOException;
|
import java.io.OutputStream;
|
import java.util.Map;
|
import java.util.TreeMap;
|
|
/**
|
* 比较矩阵处理器（判断矩阵）
|
*
|
* 用于处理模糊数学专家的判断矩阵导入导出
|
* 每个 Sheet 对应一个层级节点的判断矩阵
|
*/
|
@Slf4j
|
@AllArgsConstructor
|
public class CompareMatrixProcessor extends DataProcessorBase<Map<String, CompareMatrix>> {
|
|
private TreeRoot<HierarchyData> hierarchyTree;
|
|
@Override
|
protected String[] getHeaders() {
|
// 判断矩阵使用动态列头，这里返回空数组
|
return new String[0];
|
}
|
|
@Override
|
public String getName() {
|
return "判断矩阵";
|
}
|
|
@Override
|
protected Map<String, CompareMatrix> parseSheet(org.apache.poi.xssf.usermodel.XSSFSheet sheet) {
|
// 判断矩阵需要多 Sheet 处理，不使用此方法
|
throw new UnsupportedOperationException("判断矩阵需要使用 loadFromWorkbook 方法处理多个 Sheet");
|
}
|
|
@Override
|
protected void writeSheet(org.apache.poi.xssf.usermodel.XSSFSheet sheet, Map<String, CompareMatrix> data) {
|
// 判断矩阵需要多 Sheet 处理，不使用此方法
|
throw new UnsupportedOperationException("判断矩阵需要使用 saveWorkbook 方法处理多个 Sheet");
|
}
|
|
@Override
|
public void saveWorkbook(OutputStream outputStream, Map<String, CompareMatrix> data) throws IOException {
|
Workbook workbook = WorkbookFactory.create(true);
|
|
if(data != null && !data.isEmpty()) {
|
for(var entry : data.entrySet()) {
|
String hierarchyPath = entry.getKey();
|
CompareMatrix matrix = entry.getValue();
|
|
// 根据路径获取节点
|
var node = hierarchyTree.get(hierarchyPath);
|
if(node == null) {
|
log.warn("找不到路径对应的节点: {}", hierarchyPath);
|
continue;
|
}
|
|
// 跳过根节点（根节点没有子节点需要比较）
|
if("/".equals(hierarchyPath) || hierarchyPath == null || hierarchyPath.length() <= 1) {
|
log.debug("跳过根节点或无效路径: {}", hierarchyPath);
|
continue;
|
}
|
|
// 创建 Sheet，使用路径格式：_1-2-3
|
String sheetName = "_" + hierarchyPath.substring(1).replace("/", "-");
|
Sheet sheet = workbook.createSheet(sheetName);
|
|
// 写入标题行（第0行）
|
Row headerRow = sheet.createRow(0);
|
headerRow.createCell(0).setCellValue(""); // 左上角空单元格
|
String[] indexCols = matrix.getIndexCols();
|
for(int i = 0; i < indexCols.length; i++) {
|
headerRow.createCell(i + 1).setCellValue(indexCols[i]);
|
}
|
|
// 写入数据行
|
float[][] values = matrix.getValues();
|
for(int i = 0; i < values.length; i++) {
|
Row dataRow = sheet.createRow(i + 1);
|
dataRow.createCell(0).setCellValue(indexCols[i]); // 行索引
|
for(int j = 0; j < values[i].length; j++) {
|
dataRow.createCell(j + 1).setCellValue(values[i][j]);
|
}
|
}
|
|
// 在最后一行写入路径信息（用于显示）
|
int lastRowNum = values.length + 2; // 标题行 + 数据行 + 空行
|
Row pathRow = sheet.createRow(lastRowNum);
|
pathRow.createCell(0).setCellValue("体系路径：");
|
pathRow.createCell(1).setCellValue(hierarchyPath);
|
|
// 如果有名称路径，也显示出来
|
if(node.getNames() != null && !node.getNames().isEmpty()) {
|
Row nameRow = sheet.createRow(lastRowNum + 1);
|
nameRow.createCell(0).setCellValue("体系名称：");
|
nameRow.createCell(1).setCellValue(String.join(" / ", node.getNames()));
|
}
|
}
|
}
|
|
workbook.write(outputStream);
|
workbook.close();
|
}
|
|
@Override
|
public Map<String, CompareMatrix> loadFromWorkbook(String filePath) throws IOException {
|
return loadFromWorkbook(WorkbookFactory.create(new java.io.FileInputStream(filePath)));
|
}
|
|
@Override
|
public Map<String, CompareMatrix> loadFromWorkbook(java.io.InputStream inputStream) throws IOException {
|
return loadFromWorkbook(WorkbookFactory.create(inputStream));
|
}
|
|
private Map<String, CompareMatrix> loadFromWorkbook(Workbook workbook) {
|
Map<String, CompareMatrix> compareMatrixMap = new TreeMap<>();
|
|
int numberOfSheets = workbook.getNumberOfSheets();
|
for(int i = 0; i < numberOfSheets; i++) {
|
try {
|
String sheetName = workbook.getSheetName(i);
|
var node = sheetNameToTreeNode(hierarchyTree, sheetName);
|
if(node == null) {
|
log.warn("Sheet名称 {} 对应的节点不存在", sheetName);
|
continue;
|
}
|
|
var matrix = loadSingleCompareMatrix(workbook, i);
|
compareMatrixMap.put(node.getPath(), matrix);
|
|
} catch (Exception e) {
|
log.error("读取第 {} 个 Sheet 失败", i, e);
|
}
|
}
|
|
return compareMatrixMap;
|
}
|
|
/**
|
* 从 Sheet 名称解析出树节点
|
* Sheet 名称格式：_1-2-3
|
*/
|
private TreeNode<HierarchyData> sheetNameToTreeNode(TreeRoot<HierarchyData> hierarchy, String sheetName) {
|
if(!sheetName.startsWith("_")) {
|
log.warn("Sheet 名称格式不正确: {}", sheetName);
|
return null;
|
}
|
|
String[] split = sheetName.split("_");
|
if(split.length < 2) {
|
log.warn("Sheet 名称格式不正确: {}", sheetName);
|
return null;
|
}
|
|
String hierarchyPath = "/" + split[1].replace("-", "/");
|
return hierarchy.get(hierarchyPath);
|
}
|
|
/**
|
* 从单个 Sheet 读取判断矩阵
|
*/
|
private CompareMatrix loadSingleCompareMatrix(Workbook workbook, int sheetIndex) {
|
Sheet sheet = workbook.getSheetAt(sheetIndex);
|
|
// 读取第0行第1列开始的索引列（列名）
|
Row indexRow = sheet.getRow(0);
|
if(indexRow == null) {
|
throw new RuntimeException("Sheet " + sheetIndex + " 的标题行为空");
|
}
|
|
int totalCols = indexRow.getLastCellNum();
|
String[] indexCols = new String[totalCols - 1];
|
for(int i = 1; i < totalCols; i++) {
|
Cell cell = indexRow.getCell(i);
|
indexCols[i - 1] = cell != null ? cell.getStringCellValue() : "";
|
}
|
|
// 矩阵大小由列数决定（方阵），只读取矩阵数据行
|
int matrixSize = indexCols.length;
|
float[][] matrixValues = new float[matrixSize][matrixSize];
|
|
for(int i = 0; i < matrixSize; i++) {
|
Row dataRow = sheet.getRow(i + 1); // 从第1行开始读取
|
if(dataRow == null) {
|
// 如果行不存在，填充默认值1.0
|
for(int j = 0; j < matrixSize; j++) {
|
matrixValues[i][j] = 1.0f;
|
}
|
continue;
|
}
|
|
for(int j = 0; j < matrixSize; j++) {
|
Cell cell = dataRow.getCell(j + 1); // 从第1列开始读取
|
if(cell != null) {
|
try {
|
matrixValues[i][j] = (float) cell.getNumericCellValue();
|
} catch (Exception e) {
|
matrixValues[i][j] = 1.0f;
|
}
|
} else {
|
matrixValues[i][j] = 1.0f;
|
}
|
}
|
}
|
|
return new CompareMatrix(indexCols, matrixValues);
|
}
|
|
public static void validate(CompareMatrix matrix) {
|
var values = matrix.getValues();
|
int rows = values.length;
|
for (float[] value : values) {
|
BizResultCode.MATRIX_SIZE_ERROR.check(value.length != rows);
|
}
|
for (int i=0;i<rows;i++){
|
for(int j=i;j<rows;j++){
|
// All numbers should be positive, and elements symmetrical along the main diagonal should be opposite numbers to each other
|
BizResultCode.MATRIX_ERROR.check((values[i][j]*values[j][i]!=1) | (values[i][j]<=0));
|
}
|
}
|
}
|
|
}
|
