excel poi 文件导出，支持多sheet、多列自动合并。

参考博客：

　　http://www.oschina.net/code/snippet_565430_15074

　　增加了多sheet，多列的自动合并。

　　修改了部分过时方法和导出逻辑。

　　优化了标题，导出信息等

先看下效果，如果正常导出是这样子：

　　

自动合并后是：

　　

动态图示例：

　　

poi导出并不是一件很麻烦的事情，只是逻辑相对复杂，要考虑到各种情况。我把代码贴上，有用得到的可以帮助一下。

导出类：

package com.centit.njld.commons.testexcel;

import java.io.ByteArrayOutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.util.CellRangeAddress;

import com.centit.njld.commons.testexcel.TestExcel_Reflection;

public class TestExcel_Export {

    private static HSSFWorkbook wb;

    private static CellStyle titleStyle; // 标题行样式
    private static Font titleFont; // 标题行字体
    private static CellStyle dateStyle; // 日期行样式
    private static Font dateFont; // 日期行字体
    private static CellStyle headStyle; // 表头行样式
    private static Font headFont; // 表头行字体
    private static CellStyle contentStyle; // 内容行样式
    private static Font contentFont; // 内容行字体

    /**
     * 导出文件
     */
    public static boolean export2File(ExcelExportData setInfo,
            String outputExcelFileName) throws Exception {
        return TestExcel_FileUtil.write(outputExcelFileName, export2ByteArray(setInfo),
                true, true);
    }

    /**
     * 导出到byte数组
     */
    public static byte[] export2ByteArray(ExcelExportData setInfo)
            throws Exception {
        return export2Stream(setInfo).toByteArray();
    }

    /**
     * 导出到流
     */
    public static ByteArrayOutputStream export2Stream(ExcelExportData setInfo)
            throws Exception {
        init();
        
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

        Set<Entry<String, List<?>>> set = setInfo.getDataMap().entrySet();
        String[] sheetNames = new String[setInfo.getDataMap().size()];
        int sheetNameNum = 0;
        for (Entry<String, List<?>> entry : set) {
            sheetNames[sheetNameNum] = entry.getKey();
            sheetNameNum++;
        }
        HSSFSheet[] sheets = getSheets(setInfo.getDataMap().size(), sheetNames);
        int sheetNum = 0;
        int k = 0;
        
        for (Entry<String, List<?>> entry : set) {
            // Sheet
            List<?> objs = entry.getValue();

            // 标题行
            createTableTitleRow(setInfo, sheets, sheetNum);

            // 日期行
            createTableDateRow(setInfo, sheets, sheetNum);

            // 表头
            creatTableHeadRow(setInfo, sheets, sheetNum);

            // 表体
            String[] fieldNames = setInfo.getFieldNames().get(sheetNum);
            
            int rowNum = 3;
            for (Object obj : objs) {
                HSSFRow contentRow = sheets[sheetNum].createRow(rowNum);
                contentRow.setHeight((short) 300);
                HSSFCell[] cells = getCells(contentRow, setInfo.getFieldNames().get(sheetNum).length);
                int cellNum = 1; // 去掉一列序号，因此从1开始
                if (fieldNames != null) {
                    for (int num = 0; num < fieldNames.length; num++) {
                        Object value = TestExcel_Reflection.invokeGetterMethod(obj,fieldNames[num]);
                        cells[cellNum].setCellValue(value == null ? "" : value.toString());
                        cellNum++;
                    }
                }
                rowNum++;
            }
            
            k++;
            String[] groupColumns = null;
            if(setInfo.getGroupColumn().size()!=0){
                if(setInfo.getGroupColumn().size() >= k){
                    groupColumns = setInfo.getGroupColumn().get(sheetNum);
                }
            }
            
            if(groupColumns!=null){
                int n=0;
                for (int i = 0; i < groupColumns.length; i++) {
                    
                    String[] fieldName = setInfo.getFieldNames().get(sheetNum);
                    for (int j = 0; j < fieldName.length; j++) {
                        if(groupColumns[i].equals(fieldName[j])){
                            j++;
                            n=j;
                            break;
                        }
                    }
                    int x = 0;
                    int y = 0;
                    int z = 3;
                    int m = objs.size();
                    boolean flag = false;
                    Object val = null;
                    CellRangeAddress dateRange = null;
                    for (Object obj : objs) {
                        y++;
                        Object value = TestExcel_Reflection.invokeGetterMethod(obj,groupColumns[i]);
                        if(x==0){
                            x++;
                            val=value;
                        }else if(val.toString().equals(value.toString())){
                            x++;
                            if(m==y){
                                dateRange = new CellRangeAddress(z, x+3, n, n);
                                sheets[sheetNum].addMergedRegion(dateRange);
                            }
                        }else{
                            val=value;
                            if(flag){
                                dateRange = new CellRangeAddress(z, x+3, n, n);
                                z=x+4;
                                x=x+1;
                            }else{
                                dateRange = new CellRangeAddress(z, x+2, n, n);
                                z=x+3;
                            }
                            sheets[sheetNum].addMergedRegion(dateRange);
                            flag=true;
                        }
                    }
                }
            }
            
//            CellRangeAddress dateRange = new CellRangeAddress(3, 10, 1, 1);
//            sheets[sheetNum].addMergedRegion(dateRange);
//            
//            CellRangeAddress aa = new CellRangeAddress(11, 15, 1, 1);
//            sheets[sheetNum].addMergedRegion(aa);
//            
//            CellRangeAddress bb = new CellRangeAddress(3, 5, 2, 2);
//            sheets[sheetNum].addMergedRegion(bb);
            
//            
//            CellRangeAddress aaa = new CellRangeAddress(16, 18, 1, 1);
//            sheets[sheetNum].addMergedRegion(aaa);
            
            adjustColumnSize(sheets, sheetNum, fieldNames); // 自动调整列宽
            sheetNum++;
        }
        wb.write(outputStream);
        return outputStream;
    }

    /**
     * @Description: 初始化
     */
    private static void init() {
        wb = new HSSFWorkbook();

        titleFont = wb.createFont();
        titleStyle = wb.createCellStyle();
        dateStyle = wb.createCellStyle();
        dateFont = wb.createFont();
        headStyle = wb.createCellStyle();
        headFont = wb.createFont();
        contentStyle = wb.createCellStyle();
        contentFont = wb.createFont();

        initTitleCellStyle();
        initTitleFont();
        initDateCellStyle();
        initDateFont();
        initHeadCellStyle();
        initHeadFont();
        initContentCellStyle();
        initContentFont();
    }

    /**
     * @Description: 自动调整列宽
     */
    private static void adjustColumnSize(HSSFSheet[] sheets, int sheetNum,
            String[] fieldNames) {
        for (int i = 0; i < fieldNames.length + 1; i++) {
            sheets[sheetNum].autoSizeColumn(i, true);
        }
    }

    /**
     * @Description: 创建标题行(需合并单元格)
     */
    private static void createTableTitleRow(ExcelExportData setInfo, HSSFSheet[] sheets, int sheetNum) {
        CellRangeAddress titleRange = new CellRangeAddress(0, 0, 0, setInfo.getFieldNames().get(sheetNum).length);
        sheets[sheetNum].addMergedRegion(titleRange);
        HSSFRow titleRow = sheets[sheetNum].createRow(0);
        titleRow.setHeight((short) 800);
        HSSFCell titleCell = titleRow.createCell(0);
        titleCell.setCellStyle(titleStyle);
        titleCell.setCellValue(setInfo.getTitles()[sheetNum]);
    }

    /**
     * @Description: 创建日期行(需合并单元格)
     */
    private static void createTableDateRow(ExcelExportData setInfo,HSSFSheet[] sheets, int sheetNum) {
        CellRangeAddress dateRange = new CellRangeAddress(1, 1, 0, setInfo.getFieldNames().get(sheetNum).length);
        sheets[sheetNum].addMergedRegion(dateRange);
        HSSFRow dateRow = sheets[sheetNum].createRow(1);
        dateRow.setHeight((short) 350);
        HSSFCell dateCell = dateRow.createCell(0);
        dateCell.setCellStyle(dateStyle);
        dateCell.setCellValue(new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
    }

    /**
     * @Description: 创建表头行(需合并单元格)
     */
    private static void creatTableHeadRow(ExcelExportData setInfo,
            HSSFSheet[] sheets, int sheetNum) {
        // 表头
        HSSFRow headRow = sheets[sheetNum].createRow(2);
        headRow.setHeight((short) 350);
        // 序号列
        HSSFCell snCell = headRow.createCell(0);
        snCell.setCellStyle(headStyle);
        snCell.setCellValue("序号");
        // 列头名称
        for (int num = 1, len = setInfo.getColumnNames().get(sheetNum).length; num <= len; num++) {
            HSSFCell headCell = headRow.createCell(num);
            headCell.setCellStyle(headStyle);
            headCell.setCellValue(setInfo.getColumnNames().get(sheetNum)[num - 1]);
        }
    }

    /**
     * @Description: 创建所有的Sheet
     */
    private static HSSFSheet[] getSheets(int num, String[] names) {
        HSSFSheet[] sheets = new HSSFSheet[num];
        for (int i = 0; i < num; i++) {
            sheets[i] = wb.createSheet(names[i]);
        }
        return sheets;
    }

    /**
     * @Description: 创建内容行的每一列(附加一列序号)
     */
    private static HSSFCell[] getCells(HSSFRow contentRow, int num) {
        HSSFCell[] cells = new HSSFCell[num + 1];

        for (int i = 0, len = cells.length; i < len; i++) {
            cells[i] = contentRow.createCell(i);
            cells[i].setCellStyle(contentStyle);
        }

        // 设置序号列值，因为出去标题行和日期行，所有-2
        cells[0].setCellValue(contentRow.getRowNum() - 2);

        return cells;
    }

    /**
     * @Description: 初始化标题行样式
     */
    private static void initTitleCellStyle() {
        titleStyle.setAlignment(CellStyle.ALIGN_CENTER);
        titleStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
        titleStyle.setFont(titleFont);
        titleStyle.setFillBackgroundColor(IndexedColors.SKY_BLUE.getIndex());
    }

    /**
     * @Description: 初始化日期行样式
     */
    private static void initDateCellStyle() {
        dateStyle.setAlignment(CellStyle.ALIGN_CENTER_SELECTION);
        dateStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
        dateStyle.setFont(dateFont);
        dateStyle.setFillBackgroundColor(IndexedColors.SKY_BLUE.getIndex());
    }

    /**
     * @Description: 初始化表头行样式
     */
    private static void initHeadCellStyle() {
        headStyle.setAlignment(CellStyle.ALIGN_CENTER);
        headStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
        headStyle.setFont(headFont);
        headStyle.setFillBackgroundColor(IndexedColors.YELLOW.getIndex());
        headStyle.setBorderTop(CellStyle.BORDER_MEDIUM);
        headStyle.setBorderBottom(CellStyle.BORDER_THIN);
        headStyle.setBorderLeft(CellStyle.BORDER_THIN);
        headStyle.setBorderRight(CellStyle.BORDER_THIN);
        headStyle.setTopBorderColor(IndexedColors.BLUE.getIndex());
        headStyle.setBottomBorderColor(IndexedColors.BLUE.getIndex());
        headStyle.setLeftBorderColor(IndexedColors.BLUE.getIndex());
        headStyle.setRightBorderColor(IndexedColors.BLUE.getIndex());
    }

    /**
     * @Description: 初始化内容行样式
     */
    private static void initContentCellStyle() {
        contentStyle.setAlignment(CellStyle.ALIGN_CENTER);
        contentStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
        contentStyle.setFont(contentFont);
        contentStyle.setBorderTop(CellStyle.BORDER_THIN);
        contentStyle.setBorderBottom(CellStyle.BORDER_THIN);
        contentStyle.setBorderLeft(CellStyle.BORDER_THIN);
        contentStyle.setBorderRight(CellStyle.BORDER_THIN);
        contentStyle.setTopBorderColor(IndexedColors.BLUE.getIndex());
        contentStyle.setBottomBorderColor(IndexedColors.BLUE.getIndex());
        contentStyle.setLeftBorderColor(IndexedColors.BLUE.getIndex());
        contentStyle.setRightBorderColor(IndexedColors.BLUE.getIndex());
        contentStyle.setWrapText(true); // 字段换行
    }

    /**
     * @Description: 初始化标题行字体
     */
    private static void initTitleFont() {
        titleFont.setFontName("华文楷体");
        titleFont.setFontHeightInPoints((short) 20);
        titleFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
        titleFont.setCharSet(Font.DEFAULT_CHARSET);
        titleFont.setColor(IndexedColors.BLUE_GREY.getIndex());
    }

    /**
     * @Description: 初始化日期行字体
     */
    private static void initDateFont() {
        dateFont.setFontName("隶书");
        dateFont.setFontHeightInPoints((short) 10);
        dateFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
        dateFont.setCharSet(Font.DEFAULT_CHARSET);
        dateFont.setColor(IndexedColors.BLUE_GREY.getIndex());
    }

    /**
     * @Description: 初始化表头行字体
     */
    private static void initHeadFont() {
        headFont.setFontName("宋体");
        headFont.setFontHeightInPoints((short) 10);
        headFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
        headFont.setCharSet(Font.DEFAULT_CHARSET);
        headFont.setColor(IndexedColors.BLUE_GREY.getIndex());
    }

    /**
     * @Description: 初始化内容行字体
     */
    private static void initContentFont() {
        contentFont.setFontName("宋体");
        contentFont.setFontHeightInPoints((short) 10);
        contentFont.setBoldweight(Font.BOLDWEIGHT_NORMAL);
        contentFont.setCharSet(Font.DEFAULT_CHARSET);
        contentFont.setColor(IndexedColors.BLUE_GREY.getIndex());
    }

    /**
     * Excel导出数据类
     * @author jimmy
     */
    public static class ExcelExportData {

        /**
         * 导出数据 key:String 表示每个Sheet的名称 value:List<?> 表示每个Sheet里的所有数据行
         */
        private LinkedHashMap<String, List<?>> dataMap;

        /**
         * 每个Sheet里的顶部大标题
         */
        private String[] titles;

        /**
         * 单个sheet里的数据列标题
         */
        private List<String[]> columnNames;

        /**
         * 单个sheet里每行数据的列对应的对象属性名称
         */
        private List<String[]> fieldNames;

        private List<String[]> groupColumn;
        
        public List<String[]> getFieldNames() {
            return fieldNames;
        }

        public void setFieldNames(List<String[]> fieldNames) {
            this.fieldNames = fieldNames;
        }

        public String[] getTitles() {
            return titles;
        }

        public void setTitles(String[] titles) {
            this.titles = titles;
        }

        public List<String[]> getColumnNames() {
            return columnNames;
        }

        public void setColumnNames(List<String[]> columnNames) {
            this.columnNames = columnNames;
        }

        public LinkedHashMap<String, List<?>> getDataMap() {
            return dataMap;
        }

        public void setDataMap(LinkedHashMap<String, List<?>> dataMap) {
            this.dataMap = dataMap;
        }

        public List<String[]> getGroupColumn() {
            return groupColumn;
        }

        public void setGroupColumn(List<String[]> groupColumn) {
            this.groupColumn = groupColumn;
        }
    }
    
}

文件下载类：

package com.centit.njld.commons.testexcel;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestExcel_FileUtil {

    /**
     * 当前目录路径
     */
    public static String currentWorkDir = System.getProperty("user.dir") + "\";

    /**
     * 左填充
     * 
     * @param str
     * @param length
     * @param ch
     * @return
     */
    public static String leftPad(String str, int length, char ch) {
        if (str.length() >= length) {
            return str;
        }
        char[] chs = new char[length];
        Arrays.fill(chs, ch);
        char[] src = str.toCharArray();
        System.arraycopy(src, 0, chs, length - src.length, src.length);
        return new String(chs);

    }

    /**
     * 删除文件
     * 
     * @param fileName
     *            待删除的完整文件名
     * @return
     */
    public static boolean delete(String fileName) {
        boolean result = false;
        File f = new File(fileName);
        if (f.exists()) {
            result = f.delete();

        } else {
            result = true;
        }
        return result;
    }

    /***
     * 递归获取指定目录下的所有的文件（不包括文件夹）
     * 
     * @param obj
     * @return
     */
    public static ArrayList<File> getAllFiles(String dirPath) {
        File dir = new File(dirPath);

        ArrayList<File> files = new ArrayList<File>();

        if (dir.isDirectory()) {
            File[] fileArr = dir.listFiles();
            for (int i = 0; i < fileArr.length; i++) {
                File f = fileArr[i];
                if (f.isFile()) {
                    files.add(f);
                } else {
                    files.addAll(getAllFiles(f.getPath()));
                }
            }
        }
        return files;
    }

    /**
     * 获取指定目录下的所有文件(不包括子文件夹)
     * 
     * @param dirPath
     * @return
     */
    public static ArrayList<File> getDirFiles(String dirPath) {
        File path = new File(dirPath);
        File[] fileArr = path.listFiles();
        ArrayList<File> files = new ArrayList<File>();

        for (File f : fileArr) {
            if (f.isFile()) {
                files.add(f);
            }
        }
        return files;
    }

    /**
     * 获取指定目录下特定文件后缀名的文件列表(不包括子文件夹)
     * 
     * @param dirPath
     *            目录路径
     * @param suffix
     *            文件后缀
     * @return
     */
    public static ArrayList<File> getDirFiles(String dirPath,
            final String suffix) {
        File path = new File(dirPath);
        File[] fileArr = path.listFiles(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                String lowerName = name.toLowerCase();
                String lowerSuffix = suffix.toLowerCase();
                if (lowerName.endsWith(lowerSuffix)) {
                    return true;
                }
                return false;
            }

        });
        ArrayList<File> files = new ArrayList<File>();

        for (File f : fileArr) {
            if (f.isFile()) {
                files.add(f);
            }
        }
        return files;
    }

    /**
     * 读取文件内容
     * 
     * @param fileName
     *            待读取的完整文件名
     * @return 文件内容
     * @throws IOException
     */
    public static String read(String fileName) throws IOException {
        File f = new File(fileName);
        FileInputStream fs = new FileInputStream(f);
        String result = null;
        byte[] b = new byte[fs.available()];
        fs.read(b);
        fs.close();
        result = new String(b);
        return result;
    }

    /**
     * 写文件
     * 
     * @param fileName
     *            目标文件名
     * @param fileContent
     *            写入的内容
     * @return
     * @throws IOException
     */
    public static boolean write(String fileName, String fileContent)
            throws IOException {
        return write(fileName, fileContent, true, true);
    }

    /**
     * 写文件
     * 
     * @param fileName
     *            完整文件名(类似：/usr/a/b/c/d.txt)
     * @param fileContent
     *            文件内容
     * @param autoCreateDir
     *            目录不存在时，是否自动创建(多级)目录
     * @param autoOverWrite
     *            目标文件存在时，是否自动覆盖
     * @return
     * @throws IOException
     */
    public static boolean write(String fileName, String fileContent,
            boolean autoCreateDir, boolean autoOverwrite) throws IOException {
        return write(fileName, fileContent.getBytes(), autoCreateDir,
                autoOverwrite);
    }

    /**
     * 写文件
     * 
     * @param fileName
     *            完整文件名(类似：/usr/a/b/c/d.txt)
     * @param contentBytes
     *            文件内容的字节数组
     * @param autoCreateDir
     *            目录不存在时，是否自动创建(多级)目录
     * @param autoOverWrite
     *            目标文件存在时，是否自动覆盖
     * @return
     * @throws IOException
     */
    public static boolean write(String fileName, byte[] contentBytes,
            boolean autoCreateDir, boolean autoOverwrite) throws IOException {
        boolean result = false;
        if (autoCreateDir) {
            createDirs(fileName);
        }
        if (autoOverwrite) {
            delete(fileName);
        }
        File f = new File(fileName);
        FileOutputStream fs = new FileOutputStream(f);
        fs.write(contentBytes);
        fs.flush();
        fs.close();
        result = true;
        return result;
    }

    /**
     * 追加内容到指定文件
     * 
     * @param fileName
     * @param fileContent
     * @return
     * @throws IOException
     */
    public static boolean append(String fileName, String fileContent)
            throws IOException {
        boolean result = false;
        File f = new File(fileName);
        if (f.exists()) {
            RandomAccessFile rFile = new RandomAccessFile(f, "rw");
            byte[] b = fileContent.getBytes();
            long originLen = f.length();
            rFile.setLength(originLen + b.length);
            rFile.seek(originLen);
            rFile.write(b);
            rFile.close();
        }
        result = true;
        return result;
    }

    /**
     * 拆分文件
     * 
     * @param fileName
     *            待拆分的完整文件名
     * @param byteSize
     *            按多少字节大小拆分
     * @return 拆分后的文件名列表
     * @throws IOException
     */
    public List<String> splitBySize(String fileName, int byteSize)
            throws IOException {
        List<String> parts = new ArrayList<String>();
        File file = new File(fileName);
        int count = (int) Math.ceil(file.length() / (double) byteSize);
        int countLen = (count + "").length();
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(count,
                count * 3, 1, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(count * 2));

        for (int i = 0; i < count; i++) {
            String partFileName = file.getPath() + "."
                    + leftPad((i + 1) + "", countLen, '0') + ".part";
            threadPool.execute(new SplitRunnable(byteSize, i * byteSize,
                    partFileName, file));
            parts.add(partFileName);
        }
        return parts;
    }

    /**
     * 合并文件
     * 
     * @param dirPath
     *            拆分文件所在目录名
     * @param partFileSuffix
     *            拆分文件后缀名
     * @param partFileSize
     *            拆分文件的字节数大小
     * @param mergeFileName
     *            合并后的文件名
     * @throws IOException
     */
    public void mergePartFiles(String dirPath, String partFileSuffix,
            int partFileSize, String mergeFileName) throws IOException {
        ArrayList<File> partFiles = TestExcel_FileUtil.getDirFiles(dirPath,
                partFileSuffix);
        Collections.sort(partFiles, new FileComparator());

        RandomAccessFile randomAccessFile = new RandomAccessFile(mergeFileName,
                "rw");
        randomAccessFile.setLength(partFileSize * (partFiles.size() - 1)
                + partFiles.get(partFiles.size() - 1).length());
        randomAccessFile.close();

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                partFiles.size(), partFiles.size() * 3, 1, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(partFiles.size() * 2));

        for (int i = 0; i < partFiles.size(); i++) {
            threadPool.execute(new MergeRunnable(i * partFileSize,
                    mergeFileName, partFiles.get(i)));
        }

    }

    /**
     * 根据文件名，比较文件
     * 
     * @author yjmyzz@126.com
     * 
     */
    private class FileComparator implements Comparator<File> {
        public int compare(File o1, File o2) {
            return o1.getName().compareToIgnoreCase(o2.getName());
        }
    }

    /**
     * 创建(多级)目录
     * 
     * @param filePath
     *            完整的文件名(类似：/usr/a/b/c/d.xml)
     */
    public static void createDirs(String filePath) {
        File file = new File(filePath);
        File parent = file.getParentFile();
        if (parent != null && !parent.exists()) {
            parent.mkdirs();
        }

    }

    /**
     * 分割处理Runnable
     * 
     * @author yjmyzz@126.com
     * 
     */
    private class SplitRunnable implements Runnable {
        int byteSize;
        String partFileName;
        File originFile;
        int startPos;

        public SplitRunnable(int byteSize, int startPos, String partFileName,
                File originFile) {
            this.startPos = startPos;
            this.byteSize = byteSize;
            this.partFileName = partFileName;
            this.originFile = originFile;
        }

        public void run() {
            RandomAccessFile rFile;
            OutputStream os;
            try {
                rFile = new RandomAccessFile(originFile, "r");
                byte[] b = new byte[byteSize];
                rFile.seek(startPos);// 移动指针到每“段”开头
                int s = rFile.read(b);
                os = new FileOutputStream(partFileName);
                os.write(b, 0, s);
                os.flush();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 合并处理Runnable
     * 
     * @author yjmyzz@126.com
     * 
     */
    private class MergeRunnable implements Runnable {
        long startPos;
        String mergeFileName;
        File partFile;

        public MergeRunnable(long startPos, String mergeFileName, File partFile) {
            this.startPos = startPos;
            this.mergeFileName = mergeFileName;
            this.partFile = partFile;
        }

        public void run() {
            RandomAccessFile rFile;
            try {
                rFile = new RandomAccessFile(mergeFileName, "rw");
                rFile.seek(startPos);
                FileInputStream fs = new FileInputStream(partFile);
                byte[] b = new byte[fs.available()];
                fs.read(b);
                fs.close();
                rFile.write(b);
                rFile.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

反射类：

package com.centit.njld.commons.testexcel;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.util.Assert;

/**
 * 反射工具类.
 * 
 * 提供访问私有变量,获取泛型类型Class, 提取集合中元素的属性, 转换字符串到对象等Util函数.
 * 
 */
public class TestExcel_Reflection{

    private static Log logger = LogFactory.getLog(TestExcel_Reflection.class);

    static{
        DateLocaleConverter dc = new DateLocaleConverter();
        ConvertUtils.register(dc, Date.class);
    }

    /**
     * 调用Getter方法.
     */
    public static Object invokeGetterMethod(Object target, String propertyName){
        String getterMethodName = "get" + StringUtils.capitalize(propertyName);
        return invokeMethod(target, getterMethodName, new Class[] {},
                new Object[] {});
    }

    /**
     * 调用Setter方法.使用value的Class来查找Setter方法.
     */
    public static void invokeSetterMethod(Object target, String propertyName,
            Object value){
        invokeSetterMethod(target, propertyName, value, null);
    }

    /**
     * 调用Setter方法.
     * 
     * @param propertyType 用于查找Setter方法,为空时使用value的Class替代.
     */
    public static void invokeSetterMethod(Object target, String propertyName,
            Object value, Class<?> propertyType){
        Class<?> type = propertyType != null ? propertyType : value.getClass();
        String setterMethodName = "set" + StringUtils.capitalize(propertyName);
        invokeMethod(target, setterMethodName, new Class[] { type },
                new Object[] { value });
    }

    /**
     * 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.
     */
    public static Object getFieldValue(final Object object,
            final String fieldName){
        Field field = getDeclaredField(object, fieldName);

        if (field == null){
            throw new IllegalArgumentException("Could not find field ["
                    + fieldName + "] on target [" + object + "]");
        }

        makeAccessible(field);

        Object result = null;
        try{
            result = field.get(object);
        }
        catch (IllegalAccessException e){
            logger.error("不可能抛出的异常{}" + e.getMessage());
        }
        return result;
    }

    /**
     * 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
     */
    public static void setFieldValue(final Object object,
            final String fieldName, final Object value){
        Field field = getDeclaredField(object, fieldName);

        if (field == null){
            throw new IllegalArgumentException("Could not find field ["
                    + fieldName + "] on target [" + object + "]");
        }

        makeAccessible(field);

        try{
            field.set(object, value);
        }
        catch (IllegalAccessException e){
            logger.error("不可能抛出的异常:{}" + e.getMessage());
        }
    }

    /**
     * 直接调用对象方法, 无视private/protected修饰符.
     */
    public static Object invokeMethod(final Object object,
            final String methodName, final Class<?>[] parameterTypes,
            final Object[] parameters){
        Method method = getDeclaredMethod(object, methodName, parameterTypes);
        if (method == null){
            throw new IllegalArgumentException("Could not find method ["
                    + methodName + "] parameterType " + parameterTypes
                    + " on target [" + object + "]");
        }

        method.setAccessible(true);

        try{
            return method.invoke(object, parameters);
        }
        catch (Exception e){
            throw convertReflectionExceptionToUnchecked(e);
        }
    }

    /**
     * 循环向上转型, 获取对象的DeclaredField.
     * 
     * 如向上转型到Object仍无法找到, 返回null.
     */
    protected static Field getDeclaredField(final Object object,
            final String fieldName){
        Assert.notNull(object, "object不能为空");
        Assert.hasText(fieldName, "fieldName");
        for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass
                .getSuperclass()){
            try{
                return superClass.getDeclaredField(fieldName);
            }
            catch (NoSuchFieldException e){// NOSONAR
                // Field不在当前类定义,继续向上转型
            }
        }
        return null;
    }

    /**
     * 强行设置Field可访问.
     */
    protected static void makeAccessible(final Field field){
        if (!Modifier.isPublic(field.getModifiers())
                || !Modifier.isPublic(field.getDeclaringClass().getModifiers())){
            field.setAccessible(true);
        }
    }

    /**
     * 循环向上转型, 获取对象的DeclaredMethod.
     * 
     * 如向上转型到Object仍无法找到, 返回null.
     */
    protected static Method getDeclaredMethod(Object object, String methodName,
            Class<?>[] parameterTypes){
        Assert.notNull(object, "object不能为空");

        for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass
                .getSuperclass()){
            try{
                return superClass.getDeclaredMethod(methodName, parameterTypes);
            }
            catch (NoSuchMethodException e){// NOSONAR
                // Method不在当前类定义,继续向上转型
            }
        }
        return null;
    }

    /**
     * 通过反射, 获得Class定义中声明的父类的泛型参数的类型. 如无法找到, 返回Object.class. eg. public UserDao
     * extends HibernateDao<User>
     * 
     * @param clazz The class to introspect
     * @return the first generic declaration, or Object.class if cannot be
     * determined
     */
    @SuppressWarnings("unchecked")
    public static <T> Class<T> getSuperClassGenricType(final Class clazz){
        return getSuperClassGenricType(clazz, 0);
    }

    /**
     * 通过反射, 获得定义Class时声明的父类的泛型参数的类型. 如无法找到, 返回Object.class.
     * 
     * 如public UserDao extends HibernateDao<User,Long>
     * 
     * @param clazz clazz The class to introspect
     * @param index the Index of the generic ddeclaration,start from 0.
     * @return the index generic declaration, or Object.class if cannot be
     * determined
     */
    @SuppressWarnings("unchecked")
    public static Class getSuperClassGenricType(final Class clazz,
            final int index){
        Type genType = clazz.getGenericSuperclass();

        if (!(genType instanceof ParameterizedType)){
            logger.warn(clazz.getSimpleName()
                    + "'s superclass not ParameterizedType");
            return Object.class;
        }

        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

        if (index >= params.length || index < 0){
            logger.warn("Index: " + index + ", Size of "
                    + clazz.getSimpleName() + "'s Parameterized Type: "
                    + params.length);
            return Object.class;
        }
        if (!(params[index] instanceof Class)){
            logger.warn(clazz.getSimpleName()
                    + " not set the actual class on superclass generic parameter");
            return Object.class;
        }

        return (Class) params[index];
    }

    /**
     * 提取集合中的对象的属性(通过getter函数), 组合成List.
     * 
     * @param collection 来源集合.
     * @param propertyName 要提取的属性名.
     */
    @SuppressWarnings("unchecked")
    public static List convertElementPropertyToList(
            final Collection collection, final String propertyName){
        List list = new ArrayList();

        try{
            for (Object obj : collection){
                list.add(PropertyUtils.getProperty(obj, propertyName));
            }
        }
        catch (Exception e){
            throw convertReflectionExceptionToUnchecked(e);
        }

        return list;
    }

    /**
     * 提取集合中的对象的属性(通过getter函数), 组合成由分割符分隔的字符串.
     * 
     * @param collection 来源集合.
     * @param propertyName 要提取的属性名.
     * @param separator 分隔符.
     */
    @SuppressWarnings("unchecked")
    public static String convertElementPropertyToString(
            final Collection collection, final String propertyName,
            final String separator){
        List list = convertElementPropertyToList(collection, propertyName);
        return StringUtils.join(list, separator);
    }

    /**
     * 转换字符串到相应类型.
     * 
     * @param value 待转换的字符串
     * @param toType 转换目标类型
     */
    @SuppressWarnings("unchecked")
    public static <T> T convertStringToObject(String value, Class<T> toType){
        try{
            return (T) ConvertUtils.convert(value, toType);
        }
        catch (Exception e){
            throw convertReflectionExceptionToUnchecked(e);
        }
    }

    /**
     * 将反射时的checked exception转换为unchecked exception.
     */
    public static RuntimeException convertReflectionExceptionToUnchecked(
            Exception e){
        return convertReflectionExceptionToUnchecked(null, e);
    }

    public static RuntimeException convertReflectionExceptionToUnchecked(
            String desc, Exception e){
        desc = (desc == null) ? "Unexpected Checked Exception." : desc;
        if (e instanceof IllegalAccessException
                || e instanceof IllegalArgumentException
                || e instanceof NoSuchMethodException){
            return new IllegalArgumentException(desc, e);
        }
        else if (e instanceof InvocationTargetException){
            return new RuntimeException(desc, ((InvocationTargetException) e)
                    .getTargetException());
        }
        else if (e instanceof RuntimeException){
            return (RuntimeException) e;
        }
        return new RuntimeException(desc, e);
    }

    public static final <T> T getNewInstance(Class<T> cls)
    {
        try{
            return cls.newInstance();
        }
        catch (InstantiationException e){
            e.printStackTrace();
        }
        catch (IllegalAccessException e){
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 拷贝 source 指定的porperties 属性 到 dest中
     * 
     * @return void
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    public static void copyPorperties(Object dest, Object source,
            String[] porperties) throws InvocationTargetException,
            IllegalAccessException{
        for (String por : porperties){
            Object srcObj = invokeGetterMethod(source, por);
            if (srcObj != null){
                try{
                    BeanUtils.setProperty(dest, por, srcObj);
                }
                catch (IllegalArgumentException e){
                    e.printStackTrace();
                }
                catch (IllegalAccessException e){
                    throw e;
                }
                catch (InvocationTargetException e){
                    throw e;
                }
            }
        }
    }

    /**
     * 两者属性名一致时，拷贝source里的属性到dest里
     * 
     * @return void
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    @SuppressWarnings("unchecked")
    public static void copyPorperties(Object dest, Object source)
            throws IllegalAccessException, InvocationTargetException{
        Class srcCla = source.getClass();
        Field[] fsF = srcCla.getDeclaredFields();

        for (Field s : fsF){
            String name = s.getName();
            Object srcObj = invokeGetterMethod(source, name);
            try{
                BeanUtils.setProperty(dest, name, srcObj);
            }
            catch (IllegalArgumentException e){
                e.printStackTrace();
            }
            catch (IllegalAccessException e){
                throw e;
            }
            catch (InvocationTargetException e){
                throw e;
            }
        }
        // BeanUtils.copyProperties(dest, orig);
    }


}

测试数据模型类：

package com.centit.njld.commons.testexcel;
public class TestExcel_Model {

    public TestExcel_Model() {
        super();
    }

    public TestExcel_Model(String unit, String mtName, int jhsl, int qlsl,
            int xhsl) {
        super();
        this.unit = unit;
        this.mtName = mtName;
        this.jhsl = jhsl;
        this.qlsl = qlsl;
        this.xhsl = xhsl;
    }

    private String unit;

    private String mtName;
    
    private int jhsl;
    
    private int qlsl;
    
    private int xhsl;

    public String getUnit() {
        return unit;
    }

    public void setUnit(String unit) {
        this.unit = unit;
    }

    public String getMtName() {
        return mtName;
    }

    public void setMtName(String mtName) {
        this.mtName = mtName;
    }

    public int getJhsl() {
        return jhsl;
    }

    public void setJhsl(int jhsl) {
        this.jhsl = jhsl;
    }

    public int getQlsl() {
        return qlsl;
    }

    public void setQlsl(int qlsl) {
        this.qlsl = qlsl;
    }

    public int getXhsl() {
        return xhsl;
    }

    public void setXhsl(int xhsl) {
        this.xhsl = xhsl;
    }
    
}

测试方法

package com.centit.njld.commons.testexcel;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Random;

import com.centit.njld.commons.testexcel.TestExcel_Export.ExcelExportData;

public class TestExcel_Main {

    private static List<TestExcel_Model> getData1() {
        List<TestExcel_Model> data = new ArrayList<TestExcel_Model>();
        Random rand = new Random();
        data.add(new TestExcel_Model("城南维护所", "a",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "a",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "a",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "d",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "d",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "f",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "g",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "---以上是城南所---",    rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        
        data.add(new TestExcel_Model("什么鬼", "呵呵呵",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("什么鬼", "呵呵呵",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("什么鬼", "哈哈哈",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("什么鬼", "噗噗噗",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("什么鬼", "噗噗噗",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("什么鬼", "---以上是什么鬼---",    rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        
        data.add(new TestExcel_Model("000", "asasasa",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("000", "dfdfdfd",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("000", "gggggg",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("000", "vvvvvv",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("000", "888888",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("000", "---以上是000---",    rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        
        data.add(new TestExcel_Model("亮化所", "11111",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("亮化所", "11111",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("亮化所", "11111",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("亮化所", "---以上是亮化所---",    rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        
        return data;
    }
    
    private static List<TestExcel_Model> getData2() {
        List<TestExcel_Model> data = new ArrayList<TestExcel_Model>();
        Random rand = new Random();
        data.add(new TestExcel_Model("城南维护所", "111111",            rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "111111",            rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "333333",            rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("城南维护所", "---以上是城南--",rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));

        data.add(new TestExcel_Model("亮化所", "---以上是亮化--",    rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));    
        data.add(new TestExcel_Model("亮化所", "150W",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("亮化所", "22.2W",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("亮化所", "95W",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        data.add(new TestExcel_Model("亮化所", "95W",                rand.nextInt(100),rand.nextInt(100),rand.nextInt(100)));
        return data;
    }
    
    public static void main(String[] args) throws Exception {
        List<String[]> columNames = new ArrayList<String[]>();
        columNames.add(new String[] { "部门", "材料名称","计划数量","请领数量","消耗数量" });
        columNames.add(new String[] { "部门", "材料名称","计划数量","请领数量","消耗数量" });
        List<String[]> fieldNames = new ArrayList<String[]>();
        fieldNames.add(new String[] { "unit", "mtName","jhsl","qlsl","xhsl" });
        fieldNames.add(new String[] { "unit", "mtName","jhsl","qlsl","xhsl" });
        List<String[]> groupNames = new ArrayList<String[]>();
        groupNames.add(new String[] { "unit", "mtName" });
        groupNames.add(new String[] { "unit", "mtName" });
        
        LinkedHashMap<String, List<?>> dataMap = new LinkedHashMap<String, List<?>>();
        dataMap.put("1-sheet", getData1());
        dataMap.put("2-sheet", getData2());
        
        ExcelExportData setInfo = new ExcelExportData();
        setInfo.setDataMap(dataMap);
        setInfo.setFieldNames(fieldNames);
        setInfo.setTitles(new String[] { "Name-1", "Name-2" });
        setInfo.setGroupColumn(groupNames);
        setInfo.setColumnNames(columNames);

        System.out.println(TestExcel_Export.export2File(setInfo, "D:/ywwwwwwwwwwwwwwwww.xls"));
    }
    
}

最重要部分要看