Java XSSFReader.getWorkbookData方法代码示例

import org.apache.poi.xssf.eventusermodel.XSSFReader; //导入方法依赖的package包/类
/**
 * Create instance
 * @param inputStream sheet input stream
 * @param pluginConfig config options
 * @param writer {@link VectorContainerWriter} for writing values into vectors.
 * @param managedBuf Workspace buffer.
 */
public StAXBasedParser(final InputStream inputStream, final ExcelFormatPluginConfig pluginConfig,
                       final VectorContainerWriter writer, final ArrowBuf managedBuf,
                       final HashSet<String> columnsToProject) throws Exception {
  pkgInputStream = OPCPackage.open(inputStream);
  this.writer = writer.rootAsMap();
  this.managedBuf = managedBuf;

  final XSSFReader xssfReader = new XSSFReader(pkgInputStream);

  // Find the sheet id of the given sheet name in workbook
  try (final InputStream wbInputStream = xssfReader.getWorkbookData()) {
    final String sheetId = ExcelUtil.getSheetId(wbInputStream, pluginConfig.sheet);
    if (sheetId == null) {
      throw new SheetNotFoundException();
    }

    // Open the InputStream for sheet
    sheetInputStream = xssfReader.getSheet(sheetId);
  }


  // WARNING: XSSFReader can actually return null instances of sst and styles
  sst = xssfReader.getSharedStringsTable();
  styles = checkNotNull(xssfReader.getStylesTable(), "Expected a valid styles table instance");

  init(pluginConfig.extractHeader, pluginConfig.hasMergedCells);

  this.columnsToProject = columnsToProject;
}
 

import org.apache.poi.xssf.eventusermodel.XSSFReader; //导入方法依赖的package包/类
public void consume(File data)
{
    try
    {
        Map<String, String> refIdMap = new HashMap<String, String>();

        OPCPackage         opcPackage         = OPCPackage.open(data);
        XSSFReader         xssfReader         = new XSSFReader(opcPackage);
        SharedStringsTable sharedStringsTable = xssfReader.getSharedStringsTable();

        XMLReader      workbookParser  = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
        ContentHandler workbookHandler = new WorkbookHandler(refIdMap);
        workbookParser.setContentHandler(workbookHandler);

        InputStream workbookInputStream = xssfReader.getWorkbookData();
        InputSource workbookSource      = new InputSource(workbookInputStream);
        workbookParser.parse(workbookSource);
        workbookInputStream.close();

        XMLReader      sheetParser  = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
        ContentHandler sheetHandler = new SheetHandler(sharedStringsTable);
        sheetParser.setContentHandler(sheetHandler);

        Iterator<InputStream> sheetInputStreamIterator = xssfReader.getSheetsData();
        while (sheetInputStreamIterator.hasNext())
        {
            InputStream sheetInputStream = sheetInputStreamIterator.next();
            InputSource sheetSource = new InputSource(sheetInputStream);
            sheetParser.parse(sheetSource);
            sheetInputStream.close();
        }
    }
    catch (Throwable throwable)
    {
        logger.log(Level.WARNING, "Problem processing XSSF file \"" + data.getAbsolutePath() + "\"", throwable);
    }
}
 

import org.apache.poi.xssf.eventusermodel.XSSFReader; //导入方法依赖的package包/类
/**
 * Method used to process the whole request.
 * 
 * @param resID unique ID of resource
 * @param requestType designator of URI scheme
 * @param sheetName name of sheet
 * @param reference table, column, row or cell reference
 * @param xssfReader package reader of POI
 * @return list of values as {@code ValueExchangeExt}
 * @throws EncodingException
 * @throws EOFException
 * @throws EntityException
 * @throws InvalidFormatException not an OOXML file
 * @throws ParseException error during parsing
 * @throws IOException can't open file
 * @throws XPathParseException error during parsing
 * @throws XPathEvalException error during XPath evaluation
 * @throws NavException error during XML navigation
 */
private ValueExchangeExt processExcelRequest(String resID, String requestType,
        String sheetName, String reference, XSSFReader xssfReader) throws EncodingException,
        EOFException, EntityException, InvalidFormatException, ParseException, IOException,
        XPathParseException, XPathEvalException, NavException {
    ValueExchangeExt valList = new ValueExchangeExt();

    this.sstData = new SharedStringsData(xssfReader);
    StylesTable styles = xssfReader.getStylesTable();
    InputStream workBook = xssfReader.getWorkbookData();

    LinkedHashMap<String, InputStream> sheets = getSheets(workBook, xssfReader, sheetName);

    String xpathExp = buildXPathExp(reference);
    Boolean allSheets = sheetName.equals("*");

    if (allSheets) {
        valList.setBaseURI("/" + resID + "/" + requestType + "/");
    } else {
        valList.setBaseURI("/" + resID + "/" + requestType + "/"
                + URLEncoder.encode(sheetName, "US-ASCII") + "/");
    }

    // iterate sheets for evaluation
    for (String curSheetName : sheets.keySet()) {
        String pathPrefix = "";
        if (allSheets)
            pathPrefix = URLEncoder.encode(curSheetName, "US-ASCII");
        InputStream sheetIS = sheets.get(curSheetName);
        byte[] sheet = IOUtils.toByteArray(sheetIS);
        // evaluate XPath expression for current sheet
        valList.addValues(evalSheet(sheet, xpathExp, reference, styles, pathPrefix));
    }
    return valList;
}
 

import org.apache.poi.xssf.eventusermodel.XSSFReader; //导入方法依赖的package包/类
private void buildTables(final XSSFReader xssfReader, final XlsxWorkbookToTablesHandler workbookToTables)
        throws Exception {
    final InputStream workbookData = xssfReader.getWorkbookData();
    final XMLReader workbookParser = ExcelUtils.createXmlReader();
    workbookParser.setContentHandler(workbookToTables);
    workbookParser.parse(new InputSource(workbookData));
    FileHelper.safeClose(workbookData);
}
 

import org.apache.poi.xssf.eventusermodel.XSSFReader; //导入方法依赖的package包/类
@Override
protected void readReader(XSSFReader reader) throws Exception {
    try {
        wb = reader.getWorkbookData();
        InputSource is = new InputSource(wb);
        XMLReader parser = super.createParser();
        parser.parse(is);
    } finally {
        close();
    }
}
 

import org.apache.poi.xssf.eventusermodel.XSSFReader; //导入方法依赖的package包/类
String getSheetId(String sheetName, XSSFReader reader) throws Exception {
    this.sheetName = sheetName;
    try {
        wb = reader.getWorkbookData();
        InputSource is = new InputSource(wb);
        XMLReader parser = XlsxReader.createParser(this);
        parser.parse(is);
        return  sheetId;
    } finally {
        close();
    }
}
 

import org.apache.poi.xssf.eventusermodel.XSSFReader; //导入方法依赖的package包/类
public String generateXSSFSpreadsheetMetadata(URI baseRDFURI, byte[] spreadsheetData)
{
    logger.log(Level.FINE, "Generate XSSF Spreadsheet Metadata - Streamed (Data)");

    try
    {
        InputStream xssfWorkbookInputStream = new ByteArrayInputStream(spreadsheetData);
        OPCPackage  opcPackage              = OPCPackage.open(xssfWorkbookInputStream);
        XSSFReader  xssfReader              = new XSSFReader(opcPackage);
        StylesTable stylesTable             = xssfReader.getStylesTable();

        UUID     workbookUUID = UUID.randomUUID();
        Workbook workbook     = new Workbook(baseRDFURI.resolve('#' + workbookUUID.toString()), new HashMap<String, Sheet>());

        XMLReader      workbookParser  = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
        ContentHandler workbookHandler = new WorkbookHandler(baseRDFURI, workbook);
        workbookParser.setContentHandler(workbookHandler);

        InputStream workbookInputStream = xssfReader.getWorkbookData();
        InputSource workbookSource = new InputSource(workbookInputStream);
        workbookParser.parse(workbookSource);
        workbookInputStream.close();

        for (Sheet sheet: workbook.sheets.values())
        {
            XMLReader      sheetParser  = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
            ContentHandler sheetHandler = new SheetHandler(baseRDFURI, stylesTable, sheet);
            sheetParser.setContentHandler(sheetHandler);

            InputStream sheetInputStream = xssfReader.getSheet(sheet.refId);
            InputSource sheetSource = new InputSource(sheetInputStream);
            sheetParser.parse(sheetSource);
            sheetInputStream.close();
        }
        xssfWorkbookInputStream.close();

        XMLReader      sharedStringsParser  = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
        ContentHandler sharedStringsHandler = new SharedStringsHandler(workbook);
        sharedStringsParser.setContentHandler(sharedStringsHandler);

        InputStream sharedStringsInputStream = xssfReader.getSharedStringsData();
        InputSource sharedStringsSource = new InputSource(sharedStringsInputStream);
        sharedStringsParser.parse(sharedStringsSource);
        sharedStringsInputStream.close();

        StringBuffer rdfText = new StringBuffer();
        generateXSSFWorkbookMetadata(rdfText, workbook);

        return rdfText.toString();
    }
    catch (Throwable throwable)
    {
        logger.log(Level.WARNING, "Problem Generating during XSSF Spreadsheet Metadata Scan (Data)", throwable);

        return null;
    }
}