参考博客：
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"));
} }
最重要部分要看
