Java 使用POI'读取Excel表格；s XSSF和SAX（事件API）

我正在使用POI的XSSF和SAX（事件API）阅读Excel工作表。Excel表格中有数千行用户信息，如用户名、电子邮件、地址、年龄、部门等

我需要从Excel中读取每一行，将其转换为用户对象，并将此用户对象添加到用户对象列表中

我可以成功地阅读Excel工作表，但我不确定在阅读时应该在什么时候创建用户对象的实例并用Excel工作表中的数据填充它

下面是我的全部工作代码

    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintStream;
    import java.util.ArrayList;
    import java.util.List;

    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;

    import org.apache.poi.openxml4j.exceptions.OpenXML4JException;
    import org.apache.poi.openxml4j.opc.OPCPackage;
    import org.apache.poi.openxml4j.opc.PackageAccess;
    import org.apache.poi.ss.usermodel.BuiltinFormats;
    import org.apache.poi.ss.usermodel.DataFormatter;
    import org.apache.poi.xssf.eventusermodel.ReadOnlySharedStringsTable;
    import org.apache.poi.xssf.eventusermodel.XSSFReader;
    import org.apache.poi.xssf.model.StylesTable;
    import org.apache.poi.xssf.usermodel.XSSFCellStyle;
    import org.apache.poi.xssf.usermodel.XSSFRichTextString;
    import org.xml.sax.Attributes;
    import org.xml.sax.ContentHandler;
    import org.xml.sax.InputSource;
    import org.xml.sax.SAXException;
    import org.xml.sax.XMLReader;
    import org.xml.sax.helpers.DefaultHandler;

    public class ExcelSheetParser {

        enum xssfDataType {
            BOOL, ERROR, FORMULA, INLINESTR, SSTINDEX, NUMBER,
        }

        int countrows = 0;

        class XSSFSheetHandler extends DefaultHandler {

            /**
             * Table with styles
             */
            private StylesTable stylesTable;

            /**
             * Table with unique strings
             */
            private ReadOnlySharedStringsTable sharedStringsTable;

            /**
             * Destination for data
             */
            private final PrintStream output;

            private List<?> list = new ArrayList();

            private Class clazz;

            /**
             * Number of columns to read starting with leftmost
             */
            private final int minColumnCount;

            // Set when V start element is seen
            private boolean vIsOpen;

            // Set when cell start element is seen;
            // used when cell close element is seen.
            private xssfDataType nextDataType;

            // Used to format numeric cell values.
            private short formatIndex;
            private String formatString;
            private final DataFormatter formatter;

            private int thisColumn = -1;
            // The last column printed to the output stream
            private int lastColumnNumber = -1;

            // Gathers characters as they are seen.
            private StringBuffer value;

            /**
             * Accepts objects needed while parsing.
             * 
             * @param styles
             *            Table of styles
             * @param strings
             *            Table of shared strings
             * @param cols
             *            Minimum number of columns to show
             * @param target
             *            Sink for output
             */
            public XSSFSheetHandler(StylesTable styles,
                    ReadOnlySharedStringsTable strings, int cols, PrintStream target, Class clazz) {
                this.stylesTable = styles;
                this.sharedStringsTable = strings;
                this.minColumnCount = cols;
                this.output = target;
                this.value = new StringBuffer();
                this.nextDataType = xssfDataType.NUMBER;
                this.formatter = new DataFormatter();
                this.clazz = clazz;
            }

            public void startElement(String uri, String localName, String name,
                    Attributes attributes) throws SAXException {

                if ("inlineStr".equals(name) || "v".equals(name)) {
                    vIsOpen = true;
                    // Clear contents cache
                    value.setLength(0);
                }
                // c => cell
                else if ("c".equals(name)) {
                    // Get the cell reference
                    String r = attributes.getValue("r");
                    int firstDigit = -1;
                    for (int c = 0; c < r.length(); ++c) {
                        if (Character.isDigit(r.charAt(c))) {
                            firstDigit = c;
                            break;
                        }
                    }
                    thisColumn = nameToColumn(r.substring(0, firstDigit));

                    // Set up defaults.
                    this.nextDataType = xssfDataType.NUMBER;
                    this.formatIndex = -1;
                    this.formatString = null;
                    String cellType = attributes.getValue("t");
                    String cellStyleStr = attributes.getValue("s");
                    if ("b".equals(cellType))
                        nextDataType = xssfDataType.BOOL;
                    else if ("e".equals(cellType))
                        nextDataType = xssfDataType.ERROR;
                    else if ("inlineStr".equals(cellType))
                        nextDataType = xssfDataType.INLINESTR;
                    else if ("s".equals(cellType))
                        nextDataType = xssfDataType.SSTINDEX;
                    else if ("str".equals(cellType))
                        nextDataType = xssfDataType.FORMULA;
                    else if (cellStyleStr != null) {
                        // It's a number, but almost certainly one
                        // with a special style or format
                        int styleIndex = Integer.parseInt(cellStyleStr);
                        XSSFCellStyle style = stylesTable.getStyleAt(styleIndex);
                        this.formatIndex = style.getDataFormat();
                        this.formatString = style.getDataFormatString();
                        if (this.formatString == null)
                            this.formatString = BuiltinFormats
                                    .getBuiltinFormat(this.formatIndex);
                    }
                }

            }

            public void endElement(String uri, String localName, String name)
                    throws SAXException {

                String thisStr = null;

                // v => contents of a cell
                if ("v".equals(name)) {
                    // Process the value contents as required.
                    // Do now, as characters() may be called more than once
                    switch (nextDataType) {

                    case BOOL:
                        char first = value.charAt(0);
                        thisStr = first == '0' ? "FALSE" : "TRUE";
                        break;

                    case ERROR:
                        thisStr = "\"ERROR:" + value.toString() + '"';
                        break;

                    case FORMULA:
                        // A formula could result in a string value,
                        // so always add double-quote characters.
                        thisStr = '"' + value.toString() + '"';
                        break;

                    case INLINESTR:
                        // TODO: have seen an example of this, so it's untested.
                        XSSFRichTextString rtsi = new XSSFRichTextString(value
                                .toString());
                        thisStr = '"' + rtsi.toString() + '"';
                        break;

                    case SSTINDEX:
                        String sstIndex = value.toString();
                        try {
                            int idx = Integer.parseInt(sstIndex);
                            XSSFRichTextString rtss = new XSSFRichTextString(
                                    sharedStringsTable.getEntryAt(idx));
                            thisStr = '"' + rtss.toString() + '"';
                        } catch (NumberFormatException ex) {
                            output.println("Failed to parse SST index '" + sstIndex
                                    + "': " + ex.toString());
                        }
                        break;

                    case NUMBER:
                        String n = value.toString();
                        if (this.formatString != null)
                            thisStr = formatter.formatRawCellContents(Double
                                    .parseDouble(n), this.formatIndex,
                                    this.formatString);
                        else
                            thisStr = n;
                        break;

                    default:
                        thisStr = "(TODO: Unexpected type: " + nextDataType + ")";
                        break;
                    }

                    // Output after we've seen the string contents
                    // Emit commas for any fields that were missing on this row
                    if (lastColumnNumber == -1) {
                        lastColumnNumber = 0;
                    }
                    for (int i = lastColumnNumber; i < thisColumn; ++i)
                        output.print(',');

                    // Might be the empty string.
                    output.print(thisColumn +" : "+thisStr);

                    // Update column
                    if (thisColumn > -1)
                        lastColumnNumber = thisColumn;

                } else if ("row".equals(name)) {

                    // Print out any missing commas if needed
                    if (minColumns > 0) {
                        // Columns are 0 based
                        if (lastColumnNumber == -1) {
                            lastColumnNumber = 0;
                        }
                        for (int i = lastColumnNumber; i < (this.minColumnCount); i++) {
                            output.print(',');
                        }
                    }



                    // We're onto a new row

                    output.println();
                    output.println(countrows++);
                    lastColumnNumber = -1;

                }

            }

            /**
             * Captures characters only if a suitable element is open. Originally
             * was just "v"; extended for inlineStr also.
             */
            public void characters(char[] ch, int start, int length)
                    throws SAXException {
                if (vIsOpen)
                    value.append(ch, start, length);
            }

            /**
             * Converts an Excel column name like "C" to a zero-based index.
             * 
             * @param name
             * @return Index corresponding to the specified name
             */
            private int nameToColumn(String name) {
                int column = -1;
                for (int i = 0; i < name.length(); ++i) {
                    int c = name.charAt(i);
                    column = (column + 1) * 26 + c - 'A';
                }
                return column;
            }

        }

        // /////////////////////////////////////

        private OPCPackage xlsxPackage;
        private int minColumns;
        private PrintStream output;
        private Class clazz;

        /**
         * Creates a new XLSX -> CSV converter
         * 
         * @param pkg
         *            The XLSX package to process
         * @param output
         *            The PrintStream to output the CSV to
         * @param minColumns
         *            The minimum number of columns to output, or -1 for no minimum
         */
        public ExcelSheetParser(OPCPackage pkg, PrintStream output, int minColumns, Class clazz) {
            this.xlsxPackage = pkg;
            this.output = output;
            this.minColumns = minColumns;
            this.clazz = clazz;

        }

        /**
         * Parses and shows the content of one sheet using the specified styles and
         * shared-strings tables.
         * 
         * @param styles
         * @param strings
         * @param sheetInputStream
         */
        public void processSheet(StylesTable styles,
                ReadOnlySharedStringsTable strings, InputStream sheetInputStream)
                throws IOException, ParserConfigurationException, SAXException {

            InputSource sheetSource = new InputSource(sheetInputStream);
            SAXParserFactory saxFactory = SAXParserFactory.newInstance();
            SAXParser saxParser = saxFactory.newSAXParser();
            XMLReader sheetParser = saxParser.getXMLReader();
            ContentHandler handler = new XSSFSheetHandler(styles, strings,
                    this.minColumns, this.output, this.clazz);
            sheetParser.setContentHandler(handler);
            sheetParser.parse(sheetSource);
        }

        /**
         * Initiates the processing of the XLS workbook file to CSV.
         * 
         * @throws IOException
         * @throws OpenXML4JException
         * @throws ParserConfigurationException
         * @throws SAXException
         */
        public void process() throws IOException, OpenXML4JException,
                ParserConfigurationException, SAXException {

            ReadOnlySharedStringsTable strings = new ReadOnlySharedStringsTable(
                    this.xlsxPackage);
            XSSFReader xssfReader = new XSSFReader(this.xlsxPackage);

            StylesTable styles = xssfReader.getStylesTable();
            XSSFReader.SheetIterator iter = (XSSFReader.SheetIterator) xssfReader
                    .getSheetsData();
            int index = 0;
            while (iter.hasNext()) {
                InputStream stream = iter.next();
                String sheetName = iter.getSheetName();
                this.output.println(sheetName + " [index=" + index + "]:");
                processSheet(styles, strings, stream);
                stream.close();
                ++index;
            }
        }
    }

导入java.io.File；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.PrintStream；
导入java.util.ArrayList；
导入java.util.List；
导入javax.xml.parsers.parserConfiguration异常；
导入javax.xml.parsers.SAXParser；
导入javax.xml.parsers.SAXParserFactory；
导入org.apache.poi.openxml4j.exceptions.openxml4jeexception；
导入org.apache.poi.openxml4j.opc.OPCPackage；
导入org.apache.poi.openxml4j.opc.PackageAccess；
导入org.apache.poi.ss.usermodel.BuiltInformation；
导入org.apache.poi.ss.usermodel.DataFormatter；
导入org.apache.poi.xssf.eventusermodel.ReadOnlySharedStringsTable；
导入org.apache.poi.xssf.eventusermodel.XSSFReader；
导入org.apache.poi.xssf.model.StylesTable；
导入org.apache.poi.xssf.usermodel.XSSFCellStyle；
导入org.apache.poi.xssf.usermodel.XSSFRichTextString；
导入org.xml.sax.Attributes；
导入org.xml.sax.ContentHandler；
导入org.xml.sax.InputSource；
导入org.xml.sax.SAXException；
导入org.xml.sax.XMLReader；
导入org.xml.sax.helpers.DefaultHandler；
公共类语法分析器{
枚举xssfDataType{
BOOL，ERROR，FORMULA，INLINESTR，SSTINDEX，NUMBER，
}
int countrows=0；
类XSSFSheetHandler扩展了DefaultHandler{
/**
*样式表
*/
私人风格稳定风格稳定；
/**
*具有唯一字符串的表
*/
私有只读共享StringStable sharedStringsTable；
/**
*数据目的地
*/
私有最终打印流输出；
私有列表=新的ArrayList（）；
私人课堂；
/**
*从最左边开始读取的列数
*/
私人最终整数计数；
//当看到V开始元素时设置
私人开放；
//当看到单元格起始元素时设置；
//当看到单元闭合元件时使用。
私有xssfDataType nextDataType；
//用于格式化数值单元格值。
私人短信息索引；
私有字符串格式化字符串；
专用最终数据格式化程序格式化程序；
private int this column=-1；
//打印到输出流的最后一列
private int lastColumnNumber=-1；
//收集看到的角色。
私有字符串缓冲区值；
/**
*接受解析时所需的对象。
* 
*@param样式
*样式表
*@param字符串
*共享字符串表
*@param cols
*要显示的最小列数
*@param目标
*输出接收器
*/
公共XSSFSheetHandler（样式稳定样式，
ReadOnlySharedStringsTable字符串、int cols、PrintStream目标、类clazz）{
this.stylesTable=样式；
this.sharedStringsTable=字符串；
this.minColumnCount=cols；
这个输出=目标；
this.value=新的StringBuffer（）；
this.nextDataType=xssfDataType.NUMBER；
this.formatter=新数据格式化程序（）；
this.clazz=clazz；
}
public void startElement（字符串uri、字符串localName、字符串name、，
属性）引发SAX异常{
if（“inlineStr”.equals（name）| |“v”.equals（name））{
vIsOpen=true；
//清除内容缓存
值。设置长度（0）；
}
//c=>单元
如果（“c”。等于（名称））{
//获取单元格引用
字符串r=attributes.getValue（“r”）；
int firstDigit=-1；
对于（int c=0；c// We're onto a new row
output.println(); 
// Convert output to a new user object
// ....
// ....

else if ("row".equals(name)) {

  // use map create USER object here
}

while (iter.hasNext()) {
    InputStream stream = iter.next();
    String sheetName = iter.getSheetName();
    this.output.println(sheetName + " [index=" + index + "]:");
    processSheet(styles, strings, stream);
    stream.close();
    ++index;
   //for persisting  USERS data sheet by sheet write your code here.........
}
// for persisting complete data of all sheets write your code here...