从地图创建动态excel文件的Java代码<；标题，值>；并同时对其进行密码保护？

我正在使用rest服务，我想在运行时借助map创建一个动态excel文件，其中map的键是标题，值是列的值。此外，我想使其密码保护也，一旦我下载它，该文件是密码保护。我将密码应用到它，密码也可以正常工作，但文件已损坏

我做了很多研究，但没有得到相关的解决方案。请帮忙

import java.io.IOException;
import java.io.OutputStream;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.ResponseBuilder;
import javax.ws.rs.core.StreamingOutput;

`import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.poifs.crypt.EncryptionInfo;
import org.apache.poi.poifs.crypt.EncryptionMode;
import org.apache.poi.poifs.crypt.Encryptor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.vems.util.VEMSUtil;

@Path("/ajaxReport")
public class ReportController {

    public static Logger logger = LoggerFactory.getLogger(ReportController.class);

    private static final String password = "foobar1";

    @GET
    @Path("{attribute1}/{attribute2}")
    @Produces("application/vnd.ms-excel")
    public Response getExcelDownload(@PathParam("attribute1") String attribute1,
            @PathParam("attribute2") String attribute2)
                    throws IOException, InvalidFormatException, GeneralSecurityException {

        HashMap<String, Object> map = new HashMap<>();
        List<String> headers = new ArrayList<>();
        headers.add("Header 1");
        headers.add("Header 2");
        headers.add("Header 3");
        Map map1 = VEMSUtil.getValueMapSMS("1~2~3", "Value 1", "Value 2", "Value 3");
        List<Map<String, String>> valueList = new ArrayList<>();
        valueList.add(map1);
        map.put("header", headers);
        map.put("values", valueList);

        final XSSFWorkbook workbook = new XSSFWorkbook();
        final OPCPackage opc = workbook.getPackage();

        exportExcel(workbook, map);

        StreamingOutput fileStream = new StreamingOutput() {
            @Override
            public void write(java.io.OutputStream output) throws IOException, WebApplicationException {
                try {
                    // For enc
                    createAndWriteEncryptedWorkbook(workbook, opc, output);
                    workbook.write(output);

                } catch (Exception e) {
                }
            }
        };

        ResponseBuilder response = Response.ok(fileStream,
                "application/vnd.ms-excelformats-officedocument.spreadsheetml.sheet");
        response.header("content-disposition", "attachment; filename=" + System.currentTimeMillis() + ".xlsx");
        return response.build();
    }

    private XSSFWorkbook exportExcel(XSSFWorkbook workbook, HashMap<String, Object> map) throws IOException {
        XSSFSheet sheet = workbook.createSheet("Report Sheet");
        List<String> headers = (List<String>) map.get("header");
        List<Map<String, String>> valueList = (List<Map<String, String>>) map.get("values");
        // Create a blank sheet
        XSSFRow rowHead = sheet.createRow((short) 0);
        for (int i = 0; i < headers.size(); i++) {
            rowHead.createCell((short) i).setCellValue(headers.get(i));
        }
        int rownum = 0;
        for (int j = 0; j < valueList.size(); j++) {
            rownum = j + 1;
            XSSFRow row = sheet.createRow(rownum);
            Map<String, String> valueMap = valueList.get(j);
            Set<Map.Entry<String, String>> entrySet = valueMap.entrySet();
            int colNum = 0;
            for (Entry<String, String> entry : entrySet) {
                Cell cellFName = row.createCell(colNum, Cell.CELL_TYPE_STRING);
                cellFName.setCellValue(entry.getValue());
                colNum++;
            }
        }
        sheet.protectSheet(password);

        return workbook;
    }

    private void createAndWriteEncryptedWorkbook(XSSFWorkbook workbook, OPCPackage opc,
            OutputStream requestOutputStream) throws IOException {
        // populateWorkbook(workbook);

        try {
            // Add password protection and encrypt the file
            POIFSFileSystem fileSystem = new POIFSFileSystem();
            opc.save(getEncryptingOutputStream(fileSystem, password));
            fileSystem.writeFilesystem(requestOutputStream);
        } finally {
            // workbook.close();
        }
    }

    private OutputStream getEncryptingOutputStream(POIFSFileSystem fileSystem, String password) throws IOException {
        EncryptionInfo encryptionInfo = new EncryptionInfo(EncryptionMode.agile);
        Encryptor encryptor = encryptionInfo.getEncryptor();
        encryptor.confirmPassword(password);

        try {
            return encryptor.getDataStream(fileSystem);
        } catch (GeneralSecurityException e) {
            // TODO handle this better
            throw new RuntimeException(e);
        }
    } 
}

import java.io.IOException；
导入java.io.OutputStream；
导入java.security.GeneralSecurityException；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.Set；
导入javax.ws.rs.GET；
导入javax.ws.rs.Path；
导入javax.ws.rs.PathParam；
导入javax.ws.rs.products；
导入javax.ws.rs.WebApplicationException；
导入javax.ws.rs.core.Response；
导入javax.ws.rs.core.Response.ResponseBuilder；
导入javax.ws.rs.core.StreamingOutput；
`导入org.apache.poi.openxml4j.exceptions.InvalidFormatException；
导入org.apache.poi.openxml4j.opc.OPCPackage；
导入org.apache.poi.poifs.crypt.EncryptionInfo；
导入org.apache.poi.poifs.crypt.EncryptionMode；
导入org.apache.poi.poifs.crypt.Encryptor；
导入org.apache.poi.poifs.filesystem.poifsfsystem；
导入org.apache.poi.ss.usermodel.Cell；
导入org.apache.poi.xssf.usermodel.XSSFRow；
导入org.apache.poi.xssf.usermodel.xssfheet；
导入org.apache.poi.xssf.usermodel.xssf工作簿；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
导入com.vems.util.VEMSUtil；
@路径（“/ajaxReport”）
公共类报表控制器{
公共静态记录器Logger=LoggerFactory.getLogger（ReportController.class）；
私有静态最终字符串password=“foobar1”；
@得到
@路径（“{attribute1}/{attribute2}”）
@生成（“应用程序/vnd.ms excel”）
公共响应getExcelDownload（@PathParam（“attribute1”）字符串attribute1，
@PathParam（“attribute2”）字符串（attribute2）
抛出IOException、InvalidFormatException、GeneralSecurityException{
HashMap=newHashMap（）；
列表标题=新建ArrayList（）；
标题。添加（“标题1”）；
标题。添加（“标题2”）；
标题。添加（“标题3”）；
Map map1=VEMSUtil.getValueMapSMS（“1~2~3”、“值1”、“值2”、“值3”）；
List valueList=新的ArrayList（）；
价值清单。添加（地图1）；
地图放置（“标题”，标题）；
映射放置（“值”，值列表）；
最终XSSF工作簿=新XSSF工作簿（）；
最终OPCPackage opc=workbook.getPackage（）；
导出Excel（工作簿、地图）；
StreamingOutput fileStream=新的StreamingOutput（）{
@凌驾
public void write（java.io.OutputStream output）抛出IOException、WebApplicationException{
试一试{
//对于enc
创建并写入加密工作簿（工作簿、opc、输出）；
工作簿。编写（输出）；
}捕获（例外e）{
}
}
};
ResponseBuilder response=response.ok（文件流，
“application/vnd.ms excelformats officedocument.spreadsheetml.sheet”）；
header（“内容处置”、“附件；文件名=“+System.currentTimeMillis（）+”.xlsx”）；
返回response.build（）；
}
私有XSSFWorkbook exportExcel（XSSFWorkbook工作簿、HashMap映射）引发IOException{
XSSFSheet sheet=workbook.createSheet（“报告表”）；
List headers=（List）map.get（“header”）；
List valueList=（List）map.get（“值”）；
//创建空白工作表
XSSFRow rowHead=sheet.createRow（（短）0）；
对于（int i=0；i

那么，如果没有密码保护，它还能工作吗？您是否刚刚尝试将文件保存到生成该文件的本地帖子上的某个路径，以查看它是否打开。我无法测试您的代码，但奇怪的是，

createAndWriteEncryptedWorkbook（工作簿、opc、输出）

将加密文件写入

OutputStream

，然后写入（输出）写入