Java读取Office Excel嵌入图片Bug处理：解决重复图片与跨平台兼容性问题

最新推荐文章于 2025-12-02 21:20:38 发布

原创最新推荐文章于 2025-12-02 21:20:38 发布 · 421 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#java #excel #bug

概述

本文基于原实现改造而来，想了解具体详细实现可访问该链接：
Java读取Excel图片技术详解：悬浮式与嵌入式图片的三种实现方案（支持WPS嵌入和Office Excel嵌入）

问题背景

在处理Office Excel文件的嵌入图片时，我们遇到了两个很大的Bug：

问题1：重复图片的VM值冲突
当在Excel中插入重复的图片时，系统会为这些图片分配相同的VM值，但实际上图片资源在文件中只存储一份。这导致在通过VM值映射图片时出现一对多的情况，无法准确确定每个单元格对应的具体图片。

问题2：WPS与Office的图片处理差异
WPS行为：嵌入其他格式图片（如JPEG）时会保留原始格式，图片命名为image1.jpeg

Office行为：嵌入图片时会自动转换为JPG格式，命名为image1.jpg

冲突场景：当使用WPS嵌入JPEG图片后，再用Office Excel打开并嵌入第二个图片时，VM值会从2开始计数，导致图片索引与VM值映射错乱

原方案分析

原代码核心流程：

读取xlsx文件
扫描xl/media/
提取所有图片文件
存储为Map<索引, byte[]>
解析工作表XML获取VM映射

核心代码缺陷：
简单遍历单元格，直接映射VM值到行号
无法处理重复VM值和跨平台兼容性问题

    // 解析工作表XML获取AB列单元格的vm属性 k:vm value:行号
    private Map<Integer, Integer> parseSheetXML(InputStream is) throws Exception {
        Map<Integer, Integer> vmMap = new HashMap<>();
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(is);

        NodeList cells = doc.getElementsByTagName("c");
        for (int i = 0; i < cells.getLength(); i++) {
            Node cellNode = cells.item(i);
            if (cellNode.getNodeType() == Node.ELEMENT_NODE) {
                Element cellElement = (Element) cellNode;
                String cellRef = cellElement.getAttribute("r");

                // 只需要AB列且行号>=7
                Matcher matcher = CELL_REF_PATTERN.matcher(cellRef);
                if (matcher.matches()) {
                    int rowNum = Integer.parseInt(matcher.group(1));
                    if (rowNum >= 7) {
                        String vmAttr = cellElement.getAttribute("vm");
                        if (!vmAttr.isEmpty()) {
                            int vm = Integer.parseInt(vmAttr);
                            vmMap.put(vm, rowNum);
                        }
                    }
                }
            }
        }
        return vmMap;
    }

优化方案：

排除干扰项：过滤包含DISPIMG函数的单元格（WPS嵌入图片）
智能重映射：对VM值进行重新排序，处理重复值
多对一支持：支持多个行号映射到同一个VM值

新版完整代码实现

一、控制器接口

@RestController
@RequestMapping("/excel")
public class ExcelController {
    
    @Resource
    private ExcelService excelServiceFloatImpl;
    @Resource
    private ExcelService excelServiceImplantWpsImpl;
    @Resource
    private ExcelService excelServiceImplantOfficeImpl;
    
    // 悬浮式图片读取接口
    @PostMapping("/upload/float")
    public ResponseEntity<List<ExcelVO>> uploadExcelFloat(@RequestParam("file") MultipartFile file)
    
    // WPS嵌入式图片读取接口
    @PostMapping("/upload/implant/wps")
    public ResponseEntity<List<ExcelVO>> uploadExcelImplantWps(@RequestParam("file") MultipartFile file)
    
    // Office嵌入式图片读取接口
    @PostMapping("/upload/implant/office")
    public ResponseEntity<List<ExcelVO>> uploadExcelImplantOffice(@RequestParam("file") MultipartFile file)
}

二、抽象父类

import com.central.common.exception.BusinessException;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.openxml4j.opc.PackageAccess;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;

@Slf4j
public abstract class ExcelService {

    // 定义从第几行开始读取（从0开始计算，6则为第七行）
    public static final int START_ROW_INDEX = 6;

    /**
     * 解析上传的Excel文件
     *
     * @param file 上传的Excel文件
     * @return 解析后的数据列表
     */
    public List<ExcelVO> parseExcel(MultipartFile file) throws Exception {
        if (file == null || file.isEmpty()) {
            return Collections.emptyList();
        }
        // 校验文件扩展名
        String filename = file.getOriginalFilename();
        if (filename == null || !filename.toLowerCase().endsWith(".xlsx")) {
            throw new BusinessException("仅支持.xlsx格式文件");
        }
        if (file.getSize() > 55 * 1024 * 1024) {
            throw new BusinessException("文件大小不能超过55MB");
        }
        File tempFile = null;
        try {
            // 创建临时文件
            List<ExcelVO> result = new ArrayList<>();
            tempFile = File.createTempFile("excel_temp_", ".xlsx");
            file.transferTo(tempFile);
            try (OPCPackage pkg = OPCPackage.open(tempFile, PackageAccess.READ);
                 XSSFWorkbook workbook = new XSSFWorkbook(pkg)) {
                XSSFSheet sheet = workbook.getSheetAt(0);
                // 读取单元格数据
                for (int i = START_ROW_INDEX; i <= sheet.getLastRowNum(); i++) {
                    Row row = sheet.getRow(i);
                    if (row == null) {
                        continue;
                    }
                    ExcelVO vo = new ExcelVO();
                    vo.setRowNum(i + 1);
                    List<String> cellValues = new ArrayList<>();
                    DataFormatter dataFormatter = new DataFormatter(Locale.CHINA);
                    for (Cell cell : row) {
                        cellValues.add(dataFormatter.formatCellValue(cell));
                    }
                    vo.setCellValues(cellValues);
                    result.add(vo);
                }
                return readExcel(result, pkg, sheet);

            }
        } catch (Exception e) {
            log.error("解析失败", e);
        } finally {
            // 删除临时文件
            if (tempFile != null && tempFile.exists()) {
                boolean deleted = tempFile.delete();
                if (!deleted) {
                    log.warn("临时文件删除失败: {}", tempFile.getAbsolutePath());
                }
            }

        }
        return null;
    }

    /**
     * 保存图片到本地
     *
     * @param imageData 图片字节数组
     * @param rowNum    图片所在行号
     * @param colNum    图片所在列号
     */
    String saveImageToLocal(byte[] imageData, int rowNum, int colNum, String extension) {
        try {
            Path saveDir = Paths.get("D:\\image");
            if (!Files.exists(saveDir)) {
                Files.createDirectories(saveDir);
            }

            String fileName = String.format("row_%d_col_%d_%s.%s",
                    rowNum, colNum, UUID.randomUUID(), extension);
            Path filePath = saveDir.resolve(fileName);
            Files.write(filePath, imageData);
            return filePath.toString();
        } catch (IOException e) {
            log.error("保存图片到本地失败", e);
            return null;
        }
    }


    public abstract List<ExcelVO> readExcel(List<ExcelVO> result, OPCPackage pkg, XSSFSheet sheet) throws Exception;


}

三、辅助类

ExcelVO


import lombok.Data;

import java.util.List;
@Data
public class ExcelVO {
    // 行号
    private int rowNum;
    // 单元格值列表
    private List<String> cellValues;
    // 图片位置信息（可选）
    private ImagePosition imagePositions;
}

ImageInfo

import lombok.Data;

@Data
public class ImageInfo {
    private String extension;
    private byte[] fileBytes;
}

ImagePosition

import lombok.Data;

@Data
public class ImagePosition {
    private int row;
    private int col;
    private String url;
}

四、核心处理类（读取Office Excel嵌入式图片）


import lombok.extern.slf4j.Slf4j;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.openxml4j.opc.PackagePart;
import org.apache.poi.openxml4j.opc.PackagingURIHelper;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.springframework.stereotype.Service;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


@Service
@Slf4j
public class ExcelServiceImplantOfficeImpl extends ExcelService {
    private static final Pattern IMAGE_PATH_PATTERN = Pattern.compile("/xl/media/image(\\d+)\\.(\\w+)");


    @Override
    public List<ExcelVO> readExcel(List<ExcelVO> result, OPCPackage pkg, XSSFSheet sheet) throws Exception {
        // 获取工作表XML内容
        PackagePart sheetPart = pkg.getPart(PackagingURIHelper.createPartName("/xl/worksheets/sheet1.xml"));
        InputStream sheetStream = sheetPart.getInputStream();

        // 解析工作表XML获取AB列单元格的vm属性
        Map<Integer, List<Integer>> vmMap = parseSheetXML(sheetStream);
        sheetStream.close();

        // 获取所有图片并建立索引映射
        Map<Integer, ImageInfo> imageMap = getAllImages(pkg);

        //根据vm值匹配图片并保存
        for (Map.Entry<Integer, List<Integer>> entry : vmMap.entrySet()) {
            int vm = entry.getKey();
            if (imageMap.containsKey(vm)) {
                //office 读到的是实际行号，list集合从0开始计算所以要减1
                entry.getValue().forEach(v ->{
                    int resultIndex = v - START_ROW_INDEX - 1;
                    if (resultIndex < result.size()) {
                        ImageInfo imageInfo = imageMap.get(vm);
                        ImagePosition imagePosition = new ImagePosition();
                        imagePosition.setCol(v);
                        imagePosition.setUrl(saveImageToLocal(
                                imageInfo.getFileBytes(),
                                v,
                                28,
                                imageInfo.getExtension()
                        ));
                        ExcelVO vo = result.get(resultIndex);
                        vo.setImagePositions(imagePosition);
                    }
                });
            }
        }
        return result;
    }

    /*
    解析工作表XML获取AB列单元格的vm属性，跳过DISPIMG函数，重新排序vm值
     k:vm value:行号(可能vm相同的存在多行)
     */
    private Map<Integer, List<Integer>> parseSheetXML(InputStream is) throws Exception {
        // 第一阶段：收集所有非DISPIMG单元格（全列全行）
        Map<String, Integer> originalVmMap = new HashMap<>();
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(is);
        NodeList cells = doc.getElementsByTagName("c");

        for (int i = 0; i < cells.getLength(); i++) {
            Element cell = (Element) cells.item(i);
            NodeList functions = cell.getElementsByTagName("f");
            boolean hasDispImg = false;

            // 检查是否包含DISPIMG函数
            for (int j = 0; j < functions.getLength(); j++) {
                Element function = (Element) functions.item(j);
                if (function.getTextContent().contains("DISPIMG")) {
                    hasDispImg = true;
                    break;
                }
            }

            if (!hasDispImg) {
                String vmAttr = cell.getAttribute("vm");
                if (!vmAttr.isEmpty()) {
                    String cellRef = cell.getAttribute("r");
                    originalVmMap.put(cellRef, Integer.parseInt(vmAttr));
                }
            }
        }

        // 为所有有效单元格分配新的vm值（从1开始连续）
        Map<String, Integer> newVmMap = new HashMap<>();
        List<String> sortedCellRefs = new ArrayList<>(originalVmMap.keySet());
        // 进行排序
        sortedCellRefs.sort((ref1, ref2) -> {
            CellReference cr1 = new CellReference(ref1);
            CellReference cr2 = new CellReference(ref2);
            // 先比较行
            int rowCompare = Integer.compare(cr1.getRow(), cr2.getRow());
            if (rowCompare != 0) {
                return rowCompare;
            }
            // 行相同比较列
            return Integer.compare(cr1.getCol(), cr2.getCol());
        });

        // 原始vm -> 新vm
        Map<Integer, Integer> vmMapping = new HashMap<>();
        int newVm = 1;
        for (String cellRef : sortedCellRefs) {
            Integer originalVm = originalVmMap.get(cellRef);
            Integer mappedVm = vmMapping.get(originalVm);
            if (mappedVm == null) {
                // 如果这个原始vm值还没有映射过，则创建新的映射
                mappedVm = newVm++;
                vmMapping.put(originalVm, mappedVm);
            }
            newVmMap.put(cellRef, mappedVm);
        }

        // 筛选AB列且行号>7的单元格，收集所有行号（包括重复vm值）
        Map<Integer, List<Integer>> result = new HashMap<>();
        for (Map.Entry<String, Integer> entry : newVmMap.entrySet()) {
            String cellRef = entry.getKey();
            int row = Integer.parseInt(cellRef.replaceAll("[^0-9]", ""));
            String column = cellRef.replaceAll("[0-9]", "").toUpperCase();

            if ("AB".equalsIgnoreCase(column) && row >= 7) {
                int vmValue = entry.getValue();
                // 如果vm值不存在于结果中，创建新列表
                result.computeIfAbsent(vmValue, k -> new ArrayList<>());
                // 将行号添加到对应vm值的列表中
                result.get(vmValue).add(row);
            }
        }

        return result;
    }


    // 获取所有图片并建立索引映射 k:图片索引 value :图片信息
    private Map<Integer, ImageInfo> getAllImages(OPCPackage pkg) throws Exception {
        Map<Integer, ImageInfo> imageMap = new HashMap<>();
        // 遍历所有文件
        for (PackagePart part : pkg.getParts()) {
            String partName = part.getPartName().toString();
            if (partName.startsWith("/xl/media/")) {
                Matcher matcher = IMAGE_PATH_PATTERN.matcher(partName);
                if (matcher.matches() && "png".equalsIgnoreCase(matcher.group(2))) {
                    try (InputStream is = part.getInputStream();
                         ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
                        byte[] buffer = new byte[4096];
                        int bytesRead;
                        while ((bytesRead = is.read(buffer)) != -1) {
                            bos.write(buffer, 0, bytesRead);
                        }
                        ImageInfo imagePosition = new ImageInfo();
                        imagePosition.setExtension(matcher.group(2).toLowerCase());
                        imagePosition.setFileBytes(bos.toByteArray());
                        imageMap.put(Integer.parseInt(matcher.group(1)), imagePosition);
                    }
                }
            }
        }
        return imageMap;
    }

}