1. 你可以设一个size=100的Queue，然后把几十万数据往里扔，当扔到100个的时候它会自动帮你阻塞住，然后你可以起一堆的线程去扫这个Queue里的item而且你扫一个（queue.take()）一个，queue里实际的item就会自动减少一个，因此一个线程take后你不用担心另一个线程去”重复take”。这样我们的读和handle就可以相分离。
2. 在多线程扫queue里的item时你要告诉线程，已经到queue的底啦，没东西可取了，你可以停了，因此当所有的handle线程都碰到queue的“底”时，它们就都会自动停止了，因此我说了，基本上可以做到读完文件中的条数，所有的handle线程也正好处理完。

Map DUMMY = new HashMap();

如何对整个多线程的process过程进行计时

1. 我们需要一个封装好的方法，传入一个文件，然后用多线程handle这个文件中的行数。
2. 线程数，队列size可设
3. 需要有一个计时的功能，即从处理开始到处理结束，这个过程一共耗时多少（不少人在多线程处理任务上的计时很头疼，在例子中一并解决该问题）
4. 最后这个处理过程能够支持csv, txt, excel, 数据库...bla,bla,bla等多种格式的文件（由于篇幅有限我们在这边只实现 1)对于txt/csv和excel文件的处理 2)给出工厂方法可以便于大家自己去扩展这个FileParser。
5. 处理大数据的excel文件 ，大家都知道我们无论是使用POI还是JXL都会遇上当EXCEL的行数超过65,535行时，你只要worksheet一下，整个JVM内存直接“爆掉”的经验，那么怎么去更高效更少内存的处理大数据量的EXCEL文件呢？如一个excel含有50万行数据时。。。你怎么处理？在此例子中一并给出解决方案。

package batchpoc;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

public class BatchDTO implements Serializable {

	private String pkBtTaskId = "";
	private String taskName = "";
	private String actionType = "";
	private String taskDesc = "";
	private String status = "";
	private String commitedBy = "";
	private Date commitedTime = null;
	private String resultLog = "";
	private String batchId = "";
	private boolean headSkip = true;
	private String errorLogPath = "";
	private String logRootPath = "";
	private boolean errorFlag = false;
	private String campId = "";
	private String[] data = null;
	private long totalCount = 0;

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((actionType == null) ? 0 : actionType.hashCode());
		result = prime * result + ((batchId == null) ? 0 : batchId.hashCode());
		result = prime * result + ((campId == null) ? 0 : campId.hashCode());
		result = prime * result
				+ ((commitedBy == null) ? 0 : commitedBy.hashCode());
		result = prime * result
				+ ((commitedTime == null) ? 0 : commitedTime.hashCode());
		result = prime * result + Arrays.hashCode(data);
		result = prime * result + (errorFlag ? 1231 : 1237);
		result = prime * result
				+ ((errorLogPath == null) ? 0 : errorLogPath.hashCode());
		result = prime * result + (headSkip ? 1231 : 1237);
		result = prime * result
				+ ((logRootPath == null) ? 0 : logRootPath.hashCode());
		result = prime * result
				+ ((pkBtTaskId == null) ? 0 : pkBtTaskId.hashCode());
		result = prime * result
				+ ((resultLog == null) ? 0 : resultLog.hashCode());
		result = prime * result + ((status == null) ? 0 : status.hashCode());
		result = prime * result
				+ ((taskDesc == null) ? 0 : taskDesc.hashCode());
		result = prime * result
				+ ((taskName == null) ? 0 : taskName.hashCode());
		result = prime * result + (int) (totalCount ^ (totalCount >>> 32));
		return result;
	}

	public String getPkBtTaskId() {
		return pkBtTaskId;
	}

	public void setPkBtTaskId(String pkBtTaskId) {
		this.pkBtTaskId = pkBtTaskId;
	}

	public String getTaskName() {
		return taskName;
	}

	public void setTaskName(String taskName) {
		this.taskName = taskName;
	}

	public String getActionType() {
		return actionType;
	}

	public void setActionType(String actionType) {
		this.actionType = actionType;
	}

	public String getTaskDesc() {
		return taskDesc;
	}

	public void setTaskDesc(String taskDesc) {
		this.taskDesc = taskDesc;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public String getCommitedBy() {
		return commitedBy;
	}

	public void setCommitedBy(String commitedBy) {
		this.commitedBy = commitedBy;
	}

	public Date getCommitedTime() {
		return commitedTime;
	}

	public void setCommitedTime(Date commitedTime) {
		this.commitedTime = commitedTime;
	}

	public String getResultLog() {
		return resultLog;
	}

	public void setResultLog(String resultLog) {
		this.resultLog = resultLog;
	}

	public String getBatchId() {
		return batchId;
	}

	public void setBatchId(String batchId) {
		this.batchId = batchId;
	}

	public boolean isHeadSkip() {
		return headSkip;
	}

	public void setHeadSkip(boolean headSkip) {
		this.headSkip = headSkip;
	}

	public String getErrorLogPath() {
		return errorLogPath;
	}

	public void setErrorLogPath(String errorLogPath) {
		this.errorLogPath = errorLogPath;
	}

	public String getLogRootPath() {
		return logRootPath;
	}

	public void setLogRootPath(String logRootPath) {
		this.logRootPath = logRootPath;
	}

	public boolean isErrorFlag() {
		return errorFlag;
	}

	public void setErrorFlag(boolean errorFlag) {
		this.errorFlag = errorFlag;
	}

	public String getCampId() {
		return campId;
	}

	public void setCampId(String campId) {
		this.campId = campId;
	}

	public String[] getData() {
		return data;
	}

	public void setData(String[] data) {
		this.data = data;
	}

	public long getTotalCount() {
		return totalCount;
	}

	public void setTotalCount(long totalCount) {
		this.totalCount = totalCount;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj == null) {
			return false;
		}
		if (!(obj instanceof BatchDTO)) {
			return false;
		}
		BatchDTO other = (BatchDTO) obj;
		if (actionType == null) {
			if (other.actionType != null) {
				return false;
			}
		} else if (!actionType.equals(other.actionType)) {
			return false;
		}
		if (batchId == null) {
			if (other.batchId != null) {
				return false;
			}
		} else if (!batchId.equals(other.batchId)) {
			return false;
		}
		if (campId == null) {
			if (other.campId != null) {
				return false;
			}
		} else if (!campId.equals(other.campId)) {
			return false;
		}
		if (commitedBy == null) {
			if (other.commitedBy != null) {
				return false;
			}
		} else if (!commitedBy.equals(other.commitedBy)) {
			return false;
		}
		if (commitedTime == null) {
			if (other.commitedTime != null) {
				return false;
			}
		} else if (!commitedTime.equals(other.commitedTime)) {
			return false;
		}
		if (!Arrays.equals(data, other.data)) {
			return false;
		}
		if (errorFlag != other.errorFlag) {
			return false;
		}
		if (errorLogPath == null) {
			if (other.errorLogPath != null) {
				return false;
			}
		} else if (!errorLogPath.equals(other.errorLogPath)) {
			return false;
		}
		if (headSkip != other.headSkip) {
			return false;
		}
		if (logRootPath == null) {
			if (other.logRootPath != null) {
				return false;
			}
		} else if (!logRootPath.equals(other.logRootPath)) {
			return false;
		}
		if (pkBtTaskId == null) {
			if (other.pkBtTaskId != null) {
				return false;
			}
		} else if (!pkBtTaskId.equals(other.pkBtTaskId)) {
			return false;
		}
		if (resultLog == null) {
			if (other.resultLog != null) {
				return false;
			}
		} else if (!resultLog.equals(other.resultLog)) {
			return false;
		}
		if (status == null) {
			if (other.status != null) {
				return false;
			}
		} else if (!status.equals(other.status)) {
			return false;
		}
		if (taskDesc == null) {
			if (other.taskDesc != null) {
				return false;
			}
		} else if (!taskDesc.equals(other.taskDesc)) {
			return false;
		}
		if (taskName == null) {
			if (other.taskName != null) {
				return false;
			}
		} else if (!taskName.equals(other.taskName)) {
			return false;
		}
		if (totalCount != other.totalCount) {
			return false;
		}
		return true;
	}

}

BatchTask.java

package batchpoc;

import java.util.concurrent.BlockingQueue;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class BatchTask{
	protected final Logger logger = LoggerFactory.getLogger(this.getClass());
	public final static String TXT_IMP_EXP = "101";
	public final static String EXCEL_IMP_EXP = "102";
	public final static String TASK_RUNNING = "2";
	public final static String TASK_FINISHED = "4";
	public final static String TASK_FAILED = "5";
	protected BatchDTO taskContext = null;

	public BatchTask(BatchDTO taskContext) {
		this.taskContext = taskContext;
	}

	public abstract void doBatch() throws Exception;
}

EnumerationEngineeFactory.java，用于构建处理“读”多种格式文件的FileParser

package batchpoc;

import java.util.Map;
import java.util.concurrent.BlockingQueue;

import util.Constants;

public class EnumerationEngineeFactory {

	public static EnumerationEnginee getInstance(BlockingQueue<Map> queue,
			String type, String fileName, String colNames, boolean skipHeader,
			BatchDTO taskContext) {
		EnumerationEnginee task = null;
		if (type.equals(Constants.ENUMERATION_TXT_TASK)) {
			return new TxtEnumerationTask(queue, fileName, colNames,
					skipHeader, taskContext);
		} else if (type.equals(Constants.ENUMERATION_EXCEL_TASK)) {
			return new XLSEnumerationTask(queue, fileName, colNames,
					skipHeader, taskContext);
		}
		return task;
	}
}

EnumerationEnginee.java

package batchpoc;

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class EnumerationEnginee implements Runnable {
	protected String fileName = "";
	protected String colNames = "";
	protected final Logger logger = LoggerFactory.getLogger(this.getClass());
	protected boolean skipHeader = true;
	protected BatchDTO taskContext = null;
	protected static Map DUMMY = new HashMap();
	protected BlockingQueue<Map> queue = null;

	public EnumerationEnginee(BlockingQueue<Map> queue, String fileName,
			String colNames, boolean skipHeader, BatchDTO taskContext) {
		this.fileName = fileName;
		this.colNames = colNames;
		this.skipHeader = skipHeader;
		this.taskContext = taskContext;
		this.queue = queue;
	}

	public abstract void enumerate(String fileName, String strKeys)
			throws Exception;

	public abstract void run();

}

ImportTask.java

package batchpoc;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ImportTask implements Runnable {
	private final Logger logger = LoggerFactory.getLogger(getClass());
	private BatchDTO taskContext = null;
	private CountDownLatch threadSignal = null;
	BlockingQueue<Map> queue = null;

	public ImportTask(BlockingQueue<Map> queue, BatchDTO taskContext,
			CountDownLatch threadSignal) {
		this.taskContext = taskContext;
		this.threadSignal = threadSignal;
		this.queue = queue;
	}

	public void run() {
		boolean done = false;
		try {
			synchronized (this) {
				while (!done) {
					Map data = (Map) queue.take();
					if (data == EnumerationEnginee.DUMMY) {
						//no data
						queue.put(data);
						done = true;
					} else {
						// if (data != null) {
						for (Iterator it = data.keySet().iterator(); it
								.hasNext();) {
							String key = String.valueOf(it.next());
							System.out.print("import:>>>[" + key + "]  :  ["
									+ data.get(key) + "]");
						}
						System.out.println("\n");						
					}
				}
			}
		} catch (Exception e) {
			logger.error("import file into db error:" + e.getMessage(), e);
			try {
				Thread.interrupted();
			} catch (Exception ie) {
			}
			try {
				queue.put(EnumerationEnginee.DUMMY);
				done = true;
			} catch (Exception ex) {

			}
		} finally {
			threadSignal.countDown();
		}

	}
}

MapUtil.java-用于Map中根据key值排序用

package batchpoc;

/*
 * Author: Mk
 * Created By: 2012-08-23
 */
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class MapUtil {
	public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(
			Map<K, V> map) {
		List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(
				map.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
			public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
				return (String.valueOf(o1.getKey())).compareTo(String
						.valueOf(o2.getKey()));
			}
		});

		Map<K, V> result = new LinkedHashMap<K, V>();
		for (Map.Entry<K, V> entry : list) {
			result.put(entry.getKey(), entry.getValue());
		}
		return result;
	}
}

TxtEnumerationTask.java-这个就是专门用于读txt、csv等文本文件的FileParser，它在EnumerationEngineeFactory被调用

package batchpoc;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BlockingQueue;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TxtEnumerationTask extends EnumerationEnginee {
	private final Logger logger = LoggerFactory.getLogger(this.getClass());

	public TxtEnumerationTask(BlockingQueue<Map> queue, String txtFileName,
			String colNames, boolean skipHeader, BatchDTO taskContext) {
		super(queue, txtFileName, colNames, taskContext.isHeadSkip(),
				taskContext);

	}

	@Override
	public void run() {
		try {
			enumerate(super.fileName, super.colNames);
		} catch (Exception e) {
			logger.error("read txtFileName error, parse excel quit because :"
					+ e.getMessage(), e);
			try {
				Thread.interrupted();
			} catch (Exception ee) {
			}
		} finally {
			try {
				queue.put(DUMMY);
			} catch (Exception ex) {
			}
		}

	}

	public void enumerate(String txtFileName, String strKeys) throws Exception {
		FileInputStream is = null;
		StringBuilder sb = new StringBuilder();
		String a_line = "";
		String[] columnNames = null;
		String[] cellValues = null;
		Map dataRow = new HashMap();
		int i = 0;
		try {
			File f = new File(txtFileName);
			if (f.exists()) {
				is = new FileInputStream(new File(txtFileName));
				BufferedReader br = new BufferedReader(new InputStreamReader(
						is, "UTF-8"));
				if (skipHeader) {
					br.readLine();
				}

				while ((a_line = br.readLine()) != null) {
					if (a_line.trim().length() > 0) {
						String[] data = a_line.split(",");
						for (int index = 0; index < data.length; index++) {
							dataRow.put(String.valueOf(index), data[index]);
						}
						dataRow = MapUtil.sortByValue(dataRow);
						queue.put(dataRow);
						dataRow = new HashMap();
						i++;
					}
				}
			}
		} catch (Exception e) {
			throw new Exception("import was interrupted, error happened in "
					+ i + "  row", e);
		} finally {
			try {
				if (is != null) {
					is.close();
					is = null;
				}
			} catch (Exception e) {
			}
		}
	}
}

package batchpoc;

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BlockingQueue;

import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.openxml4j.opc.PackageAccess;

public class XLSEnumerationTask extends EnumerationEnginee {

	public XLSEnumerationTask(BlockingQueue<Map> queue, String txtFileName,
			String colNames, boolean skipHeader, BatchDTO taskContext) {
		super(queue, txtFileName, colNames, taskContext.isHeadSkip(),
				taskContext);
	}

	@Override
	public void enumerate(String fileName, String strKeys) throws Exception {
		File xlsxFile = new File(fileName);
		if (xlsxFile.exists()) {
			// The package open is instantaneous, as it should be.
			OPCPackage p = OPCPackage.open(xlsxFile.getPath(),
					PackageAccess.READ);
			Map dataMap = new HashMap();
			XLSXParser xlsxParser = new XLSXParser(p, queue, true);
			xlsxParser.process();
		}
	}

	@Override
	public void run() {
		try {
			enumerate(super.fileName, super.colNames);
		} catch (Exception e) {
			logger.error("read excel file error, parse excel quit because :"
					+ e.getMessage(), e);
			try {
				Thread.interrupted();
			} catch (Exception ee) {
			}
		} finally {
			try {
				// queue.put(DUMMY);
				queue.put(DUMMY);
			} catch (Exception ex) {
			}
		}

	}

}

XLSXParser.java-这个大了，就是用来处理大数据量的XLS文件的

package batchpoc;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.BlockingQueue;

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.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 XLSXParser {

	private final Logger logger = LoggerFactory.getLogger(getClass());

	/**
	 * The type of the data value is indicated by an attribute on the cell. The
	 * value is usually in a "v" element within the cell.
	 */
	enum xssfDataType {
		BOOL, ERROR, FORMULA, INLINESTR, SSTINDEX, NUMBER,
	}

	int countrows = 0;

	/**
	 * Derived from http://poi.apache.org/spreadsheet/how-to.html#xssf_sax_api
	 * <p/>
	 * Also see Standard ECMA-376, 1st edition, part 4, pages 1928ff, at
	 * http://www.ecma-international.org/publications/standards/Ecma-376.htm
	 * <p/>
	 * A web-friendly version is http://openiso.org/Ecma/376/Part4
	 */
	class MyXSSFSheetHandler extends DefaultHandler {

		/**
		 * Table with styles
		 */
		private StylesTable stylesTable;
		private Map<String, String> dataMap = new HashMap<String, String>();
		/**
		 * Table with unique strings
		 */
		private ReadOnlySharedStringsTable sharedStringsTable;

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

		/**
		 * 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 thisRow = 0;
		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 MyXSSFSheetHandler(StylesTable styles,
				ReadOnlySharedStringsTable strings, Map<String, String> dataMap) {
			this.stylesTable = styles;
			this.sharedStringsTable = strings;
			// this.minColumnCount = cols;
			this.value = new StringBuffer();
			this.nextDataType = xssfDataType.NUMBER;
			this.formatter = new DataFormatter();
			this.dataMap = dataMap;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see
		 * org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String,
		 * java.lang.String, java.lang.String, org.xml.sax.Attributes)
		 */
		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);
				}
			}

		}

		/**
		 * 取值
		 * 
		 * @param str
		 * @return
		 */
		public String checkNumber(String str) {
			str = str.trim();
			String str2 = "";
			if (str != null && !"".equals(str)) {
				for (int i = 0; i < str.length(); i++) {
					if (str.charAt(i) >= 48 && str.charAt(i) <= 57) {
						str2 += str.charAt(i);
					}
				}
			}
			return str2.trim();
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String,
		 * java.lang.String, java.lang.String)
		 */

		public void endElement(String uri, String localName, String name)
				throws SAXException {
			String thisStr = null;
			// System.out.println("endElement----->" + name);
			// 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());
					if (rtsi != null) {
						thisStr = rtsi.toString().trim();
						thisStr = thisStr.substring(1, thisStr.length() - 1);
					}
					break;

				case SSTINDEX:
					String sstIndex = value.toString();
					try {
						int idx = Integer.parseInt(sstIndex);
						XSSFRichTextString rtss = new XSSFRichTextString(
								sharedStringsTable.getEntryAt(idx));
						if (rtss != null) {
							/*
							 * thisStr = rtss.toString().trim()
							 * .replaceAll("\\s*", "");
							 */
							thisStr = checkNumber(rtss.toString().trim());
							/*
							 * thisStr = thisStr .substring(1, thisStr.length()
							 * - 1);
							 */
						}
					} catch (NumberFormatException ex) {
						logger.error("Failed to parse SST index ‘" + sstIndex
								+ "‘: " + ex.toString(), ex);
					}
					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) {
				// System.out.print("   col: " + i + "  ");
				// }
				// Might be the empty string.
				// output.print(thisStr);
				// System.out.println(thisStr);
				// System.out.println("thisRow...." + thisRow);
				if (thisRow > 0 && thisStr != null
						&& thisStr.trim().length() > 0) {
					// logger.info("dataMap.put()");
					dataMap.put(String.valueOf(thisColumn), thisStr);

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

			} else if ("row".equals(name)) {
				try {
					if (dataMap.keySet().size() > 0) {
						dataMap = MapUtil.sortByValue(dataMap);
						if (toQueue) {
							queue.put(dataMap);
						}
					}
				} catch (Exception e) {
					logger.error(
							"put data into queue error: " + e.getMessage(), e);
				}
				thisRow++;
				dataMap = new HashMap<String, String>();
				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 BlockingQueue<Map> queue = null;
	private boolean toQueue = false;

	// private int minColumns;

	// private PrintStream output;

	/**
	 * Creates a new XLSX -> XML 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 XLSXParser(OPCPackage pkg, BlockingQueue<Map> queue, boolean toQueue) {
		this.xlsxPackage = pkg;
		this.queue = queue;
		this.toQueue = toQueue;
		// this.minColumns = minColumns;
	}

	/**
	 * 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();
		Map<String, String> dataMap = new HashMap<String, String>();
		ContentHandler handler = new MyXSSFSheetHandler(styles, strings,
				dataMap);
		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();
			// System.out.println(sheetName + " [index=" + index + "]:");
			processSheet(styles, strings, stream);
			stream.close();
			++index;
		}
	}

	public static void main(String[] args) throws Exception {
		/*
		 * if (args.length < 1) { System.err.println("Use:");
		 * System.err.println("  XLSX2CSV <xlsx file> [min columns]"); return; }
		 */

		// File xlsxFile = new File(args[0]);
		File xlsxFile = new File("d:/test.xlsx");
		if (!xlsxFile.exists()) {
			System.err
					.println("Not found or not a file: " + xlsxFile.getPath());
			return;
		}

		int minColumns = -1;
		// if (args.length >= 2)
		// minColumns = Integer.parseInt(args[1]);

		minColumns = 2;
		// The package open is instantaneous, as it should be.
		OPCPackage p = OPCPackage.open(xlsxFile.getPath(), PackageAccess.READ);
		XLSXParser xlsxParser = new XLSXParser(p, null, false);
		xlsxParser.process();
	}

}

<!-- poi start -->
	<dependency>
		<groupId>org.apache.poi</groupId>
		<artifactId>poi</artifactId>
		<version>${poi_version}</version>
	</dependency>
	<dependency>
		<groupId>org.apache.poi</groupId>
		<artifactId>poi-ooxml-schemas</artifactId>
		<version>${poi_version}</version>
	</dependency>
	<dependency>
		<groupId>org.apache.poi</groupId>
		<artifactId>poi-scratchpad</artifactId>
		<version>${poi_version}</version>
	</dependency>
        <dependency>
	<groupId>org.apache.poi</groupId>
	<artifactId>poi-ooxml</artifactId>
	<version>${poi_version}</version>
</dependency>
<!-- poi end -->

其它辅助类