/**
 * Copyright &copy; 2012-2014 <a href="https://github.com/thinkgem/jeesite">JeeSite</a> All rights reserved.
 */
package com.nis.util.excel;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.Lists;
import com.nis.domain.FunctionRegionDict;
import com.nis.domain.FunctionServiceDict;
import com.nis.domain.SysDataDictionaryItem;
import com.nis.domain.basics.ServiceDictInfo;
import com.nis.util.DictUtils;
import com.nis.util.Encodes;
import com.nis.util.Reflections;
import com.nis.util.StringUtil;
import com.sun.xml.internal.rngom.ast.builder.CommentList;

import sun.util.logging.resources.logging;

/**
 * 导出Excel文件（导出“XLSX”格式，支持大数据量导出   @see org.apache.poi.ss.SpreadsheetVersion）
 * @author ThinkGem
 * @version 2013-04-21
 */
public class ExportExcel {
	
	private static Logger log = LoggerFactory.getLogger(ExportExcel.class);
			
	/**
	 * 工作薄对象
	 */
	private SXSSFWorkbook wb;
	
	/**
	 * 工作表对象
	 */
	private Sheet sheet;
	
	/**
	 * 工作表对象
	 */
	private Map<String,Sheet> sheets;
	
	/**
	 * 样式列表
	 */
	private Map<String, CellStyle> styles;
	
	/**
	 * 当前行号
	 */
	private int rownum;
	
	/**
	 * 当前行号
	 */
	private Map<String, Integer> rownums;
	
	/**
	 * 注解列表（Object[]{ ExcelField, Field/Method }）
	 */
	List<Object[]> annotationList = Lists.newArrayList();
	Map<String, List<Object[]>> annotationMap=new HashMap<>(); 
	
	/**
	 * //递归获取cls实体对象及父级对象的属性
	 * wx:修改，子类覆盖父类的同名方法
	 * @param list
	 * @param cls
	 */
	public void getFields(List<Field> list,Class<?> cls) {
		Field[] fields=cls.getDeclaredFields();
		if(fields != null && fields.length > 0){
			List<Field> tempList=new ArrayList<>();
			for (Field field : fields) {
				if(list.size()==0) {
					tempList.add(field);
				}else {
					boolean has=false;
					for(Field checkF:list) {
						if(checkF.getName().equals(field.getName())) {
							has=true;
							break;
						}
					}
					if(!has) {
						tempList.add(field);
					}
				}
			}
			list.addAll(tempList);
		}
		if(cls.getSuperclass() != null){
			getFields(list,cls.getSuperclass());
		}
	}
	public String[] validRegionFieldAndSetComment(String headerStr,String commentStr,FunctionRegionDict region,FunctionServiceDict service,Properties msgProp){
		String[] titleInfo=new String[2];
		if(region.getRegionType().equals(1)){//IP配置
			//ip配置需要导入的信息：srcIp srcPort destIp destPort Protocol Direction
			//确定需要导入的srcIp srcPort destIp destPort信息
			if(StringUtil.isEmpty(region.getConfigIpPortShow())){//无源目的ip和端口
				if("client_ip".equals(headerStr) 
						|| "server_ip".equals(headerStr)
						|| "client_port".equals(headerStr)
						|| "server_port".equals(headerStr)
						){
					headerStr="";
					commentStr="";
				}
			}else{
					if("client_ip".equals(headerStr)){
						if(((","+region.getConfigIpPortShow()+",").indexOf(",1,") > -1) ){
							commentStr="";
							if((","+region.getConfigIpType()+",").indexOf(",4,") > -1){
								if((","+region.getConfigIpPattern()+",").indexOf(",3,") > -1){
									commentStr=commentStr+"0.0.0.0"+"\n";
								}
								if((","+region.getConfigIpPattern()+",").indexOf(",2,") > -1){
									commentStr=commentStr+"0.0.0.0-1"+"\n";
								}
								if((","+region.getConfigIpPattern()+",").indexOf(",1,") > -1){
									commentStr=commentStr+"0.0.0.0/16"+"\n";
								}
							}
							if((","+region.getConfigIpType()+",").indexOf(",6,") > -1){
								if((","+region.getConfigIpPattern()+",").indexOf(",3,") > -1){
									commentStr=commentStr+"::"+"\n";
								}
								if((","+region.getConfigIpPattern()+",").indexOf(",2,") > -1){
									commentStr=commentStr+"::-::"+"\n";
								}
								if((","+region.getConfigIpPattern()+",").indexOf(",1,") > -1){
									commentStr=commentStr+"::/128"+"\n";
								}
							}
						}else{
							headerStr="";
							commentStr="";
						}
				}
				if("server_ip".equals(headerStr)){
					if((","+region.getConfigIpPortShow()+",").indexOf(",3,") > -1){
						commentStr="";
						if((","+region.getConfigIpType()+",").indexOf(",4,") > -1){
							if((","+region.getConfigIpPattern()+",").indexOf(",3,") > -1){
								commentStr=commentStr+"0.0.0.0"+"\n";
							}
							if((","+region.getConfigIpPattern()+",").indexOf(",2,") > -1){
								commentStr=commentStr+"0.0.0.0-1"+"\n";
							}
							if((","+region.getConfigIpPattern()+",").indexOf(",1,") > -1){
								commentStr=commentStr+"0.0.0.0/16"+"\n";
							}
						}
						if((","+region.getConfigIpType()+",").indexOf(",6,") > -1){
							if((","+region.getConfigIpPattern()+",").indexOf(",3,") > -1){
								commentStr=commentStr+"::"+"\n";
							}
							if((","+region.getConfigIpPattern()+",").indexOf(",2,") > -1){
								commentStr=commentStr+"::-::"+"\n";
							}
							if((","+region.getConfigIpPattern()+",").indexOf(",1,") > -1){
								commentStr=commentStr+"::/128"+"\n";
							}
						}
					}else{
						headerStr="";
						commentStr="";
					}
				}
				if("client_port".equals(headerStr)){
					if(((","+region.getConfigIpPortShow()+",").indexOf(",2,") > -1)){
						commentStr="";
						if((","+region.getConfigPortPattern()+",").indexOf(",1,") > -1){
							commentStr=commentStr+"0["+msgProp.getProperty("val_src_port")+"]"+"\n";
						}
						if((","+region.getConfigPortPattern()+",").indexOf(",2,") > -1){
							commentStr=commentStr+"0/65535["+msgProp.getProperty("val_src_port_mask")+"]"+"\n";
						}
					}else{
						headerStr="";
						commentStr="";
					}
				}
				if("server_port".equals(headerStr)){
					if((","+region.getConfigIpPortShow()+",").indexOf(",4,") > -1){
						commentStr="";
						if((","+region.getConfigPortPattern()+",").indexOf(",1,") > -1){
							commentStr=commentStr+"0["+msgProp.getProperty("val_src_port")+"]"+"\n";
						}
						if((","+region.getConfigPortPattern()+",").indexOf(",2,") > -1){
							commentStr=commentStr+"0/65535["+msgProp.getProperty("val_src_port_mask")+"]"+"\n";
						}
					}else{
						headerStr="";
						commentStr="";
					}
				}
			} 
			//导入的Protocol
			if("protocol".equals(headerStr)){
				if(service.getFunctionId().equals(5) ){
					commentStr="";
					//block tcp
					if(service.getAction().equals(16) ){
						List<SysDataDictionaryItem> protocol=DictUtils.getDictList("PROTOCOL");
						if(protocol !=null && protocol.size()>0){
							for (SysDataDictionaryItem sysDataDictionaryItem : protocol) {
								if(sysDataDictionaryItem.getItemCode().equals(6)){
									commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+sysDataDictionaryItem.getItemValue()+"\n";
								}
							}
						}
					}else{
						commentStr="";
						List<SysDataDictionaryItem> protocol=DictUtils.getDictList("PROTOCOL");
						if(protocol !=null && protocol.size()>0){
							for (SysDataDictionaryItem sysDataDictionaryItem : protocol) {
								if((","+region.getConfigProtocol()+",").indexOf(","+sysDataDictionaryItem.getItemCode()+",") >-1){
									if(StringUtil.isEmpty(msgProp.getProperty(sysDataDictionaryItem.getItemValue()))){
										commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+sysDataDictionaryItem.getItemValue()+"\n";
									}else{
										commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+msgProp.getProperty(sysDataDictionaryItem.getItemValue())+"\n";
									}
									
								}
							}
						}
					}
				}else{
					if(StringUtil.isEmpty(region.getConfigProtocol())){
						headerStr="";
						commentStr="";
					}else{
						commentStr="";
						List<SysDataDictionaryItem> protocol=DictUtils.getDictList("PROTOCOL");
						if(protocol !=null && protocol.size()>0){
							for (SysDataDictionaryItem sysDataDictionaryItem : protocol) {
								if((","+region.getConfigProtocol()+",").indexOf(","+sysDataDictionaryItem.getItemCode()+",") >-1){
									if(StringUtil.isEmpty(msgProp.getProperty(sysDataDictionaryItem.getItemValue()))){
										commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+sysDataDictionaryItem.getItemValue()+"\n";
									}else{
										commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+msgProp.getProperty(sysDataDictionaryItem.getItemValue())+"\n";
									}
									
								}
							}
							if(StringUtil.isEmpty(commentStr)){
								headerStr="";
								commentStr="";
							}
						}
					}
				}
			}
			
			//导入的Direction
			if("direction".equals(headerStr)){
				if(StringUtil.isEmpty(region.getConfigDirection())){
					headerStr="";
					commentStr="";
				}else{
					commentStr="";
					List<SysDataDictionaryItem> direction=DictUtils.getDictList("DIRECTION");
					if(direction !=null && direction.size()>0){
						for (SysDataDictionaryItem sysDataDictionaryItem : direction) {
							if(((","+region.getConfigDirection()+",").indexOf(sysDataDictionaryItem.getItemCode()) >-1) && StringUtil.isEmpty(msgProp.getProperty(sysDataDictionaryItem.getItemValue()))){
								commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+sysDataDictionaryItem.getItemValue()+"\n";
							}else if((","+region.getConfigDirection()+",").indexOf(sysDataDictionaryItem.getItemCode()) >-1){
								commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+msgProp.getProperty(sysDataDictionaryItem.getItemValue())+"\n";
							}
						}
						if(StringUtil.isEmpty(commentStr)){
							headerStr="";
							commentStr="";
						}
					}
				}
			}
			
			//导入的限速
			if("ratelimit".equals(headerStr)){
				commentStr="";
				List<SysDataDictionaryItem> ratelimit=DictUtils.getDictList("RATE_LIMIT");
				if(ratelimit !=null && ratelimit.size()>0){
					for (SysDataDictionaryItem sysDataDictionaryItem : ratelimit) {
						if(StringUtil.isEmpty(msgProp.getProperty(sysDataDictionaryItem.getItemValue()))){
							commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+sysDataDictionaryItem.getItemValue()+"\n";
						}else{
							commentStr=commentStr+sysDataDictionaryItem.getItemCode()+":"+msgProp.getProperty(sysDataDictionaryItem.getItemValue())+"\n";
						}
					}
				}
			}
		}
		titleInfo[0]=headerStr;
		titleInfo[1]=commentStr;
		return titleInfo;
	}
	/**
	 * //递归获取cls实体对象及父级对象的method
	 * @param list
	 * @param cls
	 */
	public void getMethods(List<Method> list,Class<?> cls) {
		Method[] methods=cls.getDeclaredMethods();
		if(methods != null && methods.length > 0){
			List<Method> tempList=new ArrayList<>();
			for (Method method : methods) {
				if(list.size()==0) {
					tempList.add(method);
				}else {
					boolean has=false;
					for(Method checkM:list) {
						if(checkM.getName().equals(method.getName())) {
							has=true;
							break;
						}
					}
					if(!has) {
						tempList.add(method);
					}
				}
			}
			list.addAll(tempList);
		}
		if(cls.getSuperclass() != null){
			getMethods(list,cls.getSuperclass());
		}
	}
	
	/**
	 * 构造函数
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param cls 实体对象，通过annotation.ExportField获取标题
	 */
	public ExportExcel(String title, Class<?> cls){
		this(title, cls, 1);
	}
	/**
	 * 构造函数
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param cls 实体对象，通过annotation.ExportField获取标题
	 * @param type 导出类型（1:导出数据；2：导出模板）
	 * @param groups 导入分组
	 */
	public ExportExcel(String title, Class<?> cls, int type, int... groups){
		List<Field> list=new ArrayList<Field>();
		// Get annotation field 
		//递归获取cls实体对象及父级对象的属性
		getFields(list, cls);
		
		if(!StringUtil.isEmpty(list)){
			for (Field f : list){
				ExcelField ef = f.getAnnotation(ExcelField.class);
				if (ef != null && (ef.type()==0 || ef.type()==type)){
					if (groups!=null && groups.length>0){
						boolean inGroup = false;
						for (int g : groups){
							if (inGroup){
								break;
							}
							for (int efg : ef.groups()){
								if (g == efg){
									inGroup = true;
									annotationList.add(new Object[]{ef, f});
									break;
								}
							}
						}
					}else{
						annotationList.add(new Object[]{ef, f});
					}
				}
			}
		}
		List<Method> ms=new ArrayList<Method>();
		// Get annotation method
		//递归获取cls实体对象及父级对象的属性
		getMethods(ms, cls);
		if(!StringUtil.isEmpty(ms)){
			for (Method m : ms){
				ExcelField ef = m.getAnnotation(ExcelField.class);
				if (ef != null && (ef.type()==0 || ef.type()==type)){
					if (groups!=null && groups.length>0){
						boolean inGroup = false;
						for (int g : groups){
							if (inGroup){
								break;
							}
							for (int efg : ef.groups()){
								if (g == efg){
									inGroup = true;
									annotationList.add(new Object[]{ef, m});
									break;
								}
							}
						}
					}else{
						annotationList.add(new Object[]{ef, m});
					}
				}
			}
		}
		// Field sorting
		Collections.sort(annotationList, new Comparator<Object[]>() {
			public int compare(Object[] o1, Object[] o2) {
				return new Integer(((ExcelField)o1[0]).sort()).compareTo(
						new Integer(((ExcelField)o2[0]).sort()));
			};
		});
		// Initialize
		List<String> headerList = Lists.newArrayList();
		List<String> commentList = Lists.newArrayList();
		for (Object[] os : annotationList){
			String titleStr = ((ExcelField)os[0]).title();
			String commentStr = ((ExcelField)os[0]).comment();
			// 如果是导出，则去掉注释
			if (type==1){
				commentStr="";
			}
			headerList.add(titleStr);
			commentList.add(commentStr);
		}
		initialize(title, headerList,commentList);
	}
	/**
	 * 构造函数
	 * @param FunctionRegionDict region信息
	 * @param msgProp 国际化配置
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param cls 实体对象，通过annotation.ExportField获取标题
	 * @param type 导出类型（1:导出数据；2：导出模板）
	 * @param groups 导入分组
	 */
	public ExportExcel(FunctionServiceDict service,FunctionRegionDict region,Properties msgProp,String title, Class<?> cls, int type, int... groups){
		List<Field> list=new ArrayList<Field>();
		// Get annotation field 
		//递归获取cls实体对象及父级对象的属性
		getFields(list, cls);
		
		if(!StringUtil.isEmpty(list)){
			for (Field f : list){
				ExcelField ef = f.getAnnotation(ExcelField.class);
				if (ef != null && (ef.type()==0 || ef.type()==type)){
					if (groups!=null && groups.length>0){
						boolean inGroup = false;
						for (int g : groups){
							if (inGroup){
								break;
							}
							for (int efg : ef.groups()){
								if (g == efg){
									inGroup = true;
									annotationList.add(new Object[]{ef, f});
									break;
								}
							}
						}
					}else{
						annotationList.add(new Object[]{ef, f});
					}
				}
			}
		}
		List<Method> ms=new ArrayList<Method>();
		// Get annotation method
		//递归获取cls实体对象及父级对象的属性
		getMethods(ms, cls);
		if(!StringUtil.isEmpty(ms)){
			for (Method m : ms){
				ExcelField ef = m.getAnnotation(ExcelField.class);
				if (ef != null && (ef.type()==0 || ef.type()==type)){
					if (groups!=null && groups.length>0){
						boolean inGroup = false;
						for (int g : groups){
							if (inGroup){
								break;
							}
							for (int efg : ef.groups()){
								if (g == efg){
									inGroup = true;
									annotationList.add(new Object[]{ef, m});
									break;
								}
							}
						}
					}else{
						annotationList.add(new Object[]{ef, m});
					}
				}
			}
		}
		// Field sorting
		Collections.sort(annotationList, new Comparator<Object[]>() {
			public int compare(Object[] o1, Object[] o2) {
				return new Integer(((ExcelField)o1[0]).sort()).compareTo(
						new Integer(((ExcelField)o2[0]).sort()));
			};
		});
		// Initialize
		List<String> headerList = Lists.newArrayList();
		List<String> commentList = Lists.newArrayList();
		for (Object[] os : annotationList){
			String titleStr = ((ExcelField)os[0]).title();
			String commentStr = ((ExcelField)os[0]).comment();
			
			// 如果是导出，则去掉注释
			if (type==1){
				commentStr="";
			}else{
				//判断此业务导出模板内容，设置导入提示信息
				String[] titleInfo=validRegionFieldAndSetComment(titleStr,commentStr,region,service,msgProp);
 				titleStr=titleInfo[0];
				commentStr=titleInfo[1];
			}
			if(!StringUtil.isEmpty(titleStr)){
				headerList.add(msgProp.getProperty(titleStr)==null?titleStr:msgProp.getProperty(titleStr));
				commentList.add(commentStr);
			}
			
		}
		initialize(title, headerList,commentList);
	}
	/**
	 * 构造函数
	 * @param msgProp 国际化配置
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param cls 实体对象，通过annotation.ExportField获取标题
	 * @param type 导出类型（1:导出数据；2：导出模板）
	 * @param groups 导入分组
	 */
	public ExportExcel(Properties msgProp,String title, Class<?> cls, int type, int... groups){
		List<Field> list=new ArrayList<Field>();
		// Get annotation field 
		//递归获取cls实体对象及父级对象的属性
		getFields(list, cls);
		
		if(!StringUtil.isEmpty(list)){
			for (Field f : list){
				ExcelField ef = f.getAnnotation(ExcelField.class);
				if (ef != null && (ef.type()==0 || ef.type()==type)){
					if (groups!=null && groups.length>0){
						boolean inGroup = false;
						for (int g : groups){
							if (inGroup){
								break;
							}
							for (int efg : ef.groups()){
								if (g == efg){
									inGroup = true;
									annotationList.add(new Object[]{ef, f});
									break;
								}
							}
						}
					}else{
						annotationList.add(new Object[]{ef, f});
					}
				}
			}
		}
		List<Method> ms=new ArrayList<Method>();
		// Get annotation method
		//递归获取cls实体对象及父级对象的属性
		getMethods(ms, cls);
		if(!StringUtil.isEmpty(ms)){
			for (Method m : ms){
				ExcelField ef = m.getAnnotation(ExcelField.class);
				if (ef != null && (ef.type()==0 || ef.type()==type)){
					if (groups!=null && groups.length>0){
						boolean inGroup = false;
						for (int g : groups){
							if (inGroup){
								break;
							}
							for (int efg : ef.groups()){
								if (g == efg){
									inGroup = true;
									annotationList.add(new Object[]{ef, m});
									break;
								}
							}
						}
					}else{
						annotationList.add(new Object[]{ef, m});
					}
				}
			}
		}
		// Field sorting
		Collections.sort(annotationList, new Comparator<Object[]>() {
			public int compare(Object[] o1, Object[] o2) {
				return new Integer(((ExcelField)o1[0]).sort()).compareTo(
						new Integer(((ExcelField)o2[0]).sort()));
			};
		});
		// Initialize
		List<String> headerList = Lists.newArrayList();
		List<String> commentList = Lists.newArrayList();
		for (Object[] os : annotationList){
			String titleStr = ((ExcelField)os[0]).title();
			String commentStr = ((ExcelField)os[0]).comment();
			
			// 如果是导出，则去掉注释
			if (type==1){
				commentStr="";
			}
			if(!StringUtil.isEmpty(titleStr)){
				headerList.add(msgProp.getProperty(titleStr)==null?titleStr:msgProp.getProperty(titleStr));
				commentList.add(commentStr);
			}
			
		}
		initialize(title, headerList,commentList);
	}
	/**
	 * 构造函数
	 * @param msgProp 国际化配置
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param cls 实体对象，通过annotation.ExportField获取标题
	 * @param type 导出类型（1:导出数据；2：导出模板）
	 * @param groups 导入分组
	 */
	public ExportExcel(String columns,Properties msgProp,String title, Class<?> cls, int type, int... groups){
		String[] cloumnArray=columns.split(",");
		List<Field> list=new ArrayList<Field>();
		// Get annotation field 
		//递归获取cls实体对象及父级对象的属性
		getFields(list, cls);
		
		if(!StringUtil.isEmpty(list)){
			for (Field f : list){
				ExcelField ef = f.getAnnotation(ExcelField.class);
				/*if(ef==null || StringUtil.isEmpty(ef.title())){
					break;
				}
				String titleP=StringUtil.isEmpty(msgProp.get(ef.title())) ? ef.title().toString():msgProp.get(ef.title()).toString();
				boolean export=false;
				for(String column:cloumnArray) {
					
					if(ef!=null&&column.equals(titleP)) {
						export=true;
						break;
					}
				}
				if(export) {*/
				if (ef != null && (ef.type()==0 || ef.type()==type)){
					if (groups!=null && groups.length>0){
						boolean inGroup = false;
						for (int g : groups){
							if (inGroup){
								break;
							}
							for (int efg : ef.groups()){
								if (g == efg){
									inGroup = true;
									annotationList.add(new Object[]{ef, f});
									break;
								}
							}
						}
					}else{
						annotationList.add(new Object[]{ef, f});
					}
				}
				/*}*/
			}
		}
		List<Method> ms=new ArrayList<Method>();
		// Get annotation method
		//递归获取cls实体对象及父级对象的属性
		getMethods(ms, cls);
		if(!StringUtil.isEmpty(ms)){
			for (Method m : ms){
				ExcelField ef = m.getAnnotation(ExcelField.class);
				boolean export=false;
				for(String column:cloumnArray) {
					if(ef!=null&&column.equals(ef.title())) {
						export=true;
						break;
					}
				}
				if(export) {
					if (ef != null && (ef.type()==0 || ef.type()==type)){
						if (groups!=null && groups.length>0){
							boolean inGroup = false;
							for (int g : groups){
								if (inGroup){
									break;
								}
								for (int efg : ef.groups()){
									if (g == efg){
										inGroup = true;
										annotationList.add(new Object[]{ef, m});
										break;
									}
								}
							}
						}else{
							annotationList.add(new Object[]{ef, m});
						}
					}
				}
			}
		}
		// Field sorting
		Collections.sort(annotationList, new Comparator<Object[]>() {
			public int compare(Object[] o1, Object[] o2) {
				return new Integer(((ExcelField)o1[0]).sort()).compareTo(
						new Integer(((ExcelField)o2[0]).sort()));
			};
		});
		// Initialize
		List<String> headerList = Lists.newArrayList();
		List<String> commentList = Lists.newArrayList();
		for (Object[] os : annotationList){
			String titleStr = ((ExcelField)os[0]).title();
			String commentStr = ((ExcelField)os[0]).comment();
			// 如果是导出，则去掉注释
			if (type==1){
				commentStr="";
			}
			headerList.add(msgProp.getProperty(titleStr)==null?titleStr:msgProp.getProperty(titleStr));
			commentList.add(commentStr);
		}
		initialize(title, headerList,commentList);
	}
	
	/**
	 * 构造函数
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param headers 表头数组
	 */
	public ExportExcel(String title, String[] headers, String[] comments) {
		initialize(title, Lists.newArrayList(headers), Lists.newArrayList(comments));
	}
	
	/**
	 * 构造函数
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param headerList 表头列表
	 * @param commentList 注释列表
	 */
	public ExportExcel(String title, List<String> headerList, List<String> commentList) {
		initialize(title, headerList,commentList);
	}
	
	
	/**
	 * 初始化函数
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param headerList 表头列表
	 */
	private void initialize(String title, List<String> headerList, List<String> commentList) {
		this.wb = new SXSSFWorkbook(500);
		this.sheet = wb.createSheet("Export");
		this.styles = createStyles(wb);
		// Create title
		if (StringUtils.isNotBlank(title)){
			Row titleRow = sheet.createRow(rownum++);
			titleRow.setHeightInPoints(30);
			Cell titleCell = titleRow.createCell(0);
			titleCell.setCellStyle(styles.get("title"));
			titleCell.setCellValue(title);
			sheet.addMergedRegion(new CellRangeAddress(titleRow.getRowNum(),
					titleRow.getRowNum(), titleRow.getRowNum(), headerList.size()-1));
		}
		// Create header
		if (headerList == null){
			throw new RuntimeException("headerList not null!");
		}
		Row headerRow = sheet.createRow(rownum++);
		headerRow.setHeightInPoints(16);
		for (int i = 0; i < headerList.size(); i++) {
			Cell cell = headerRow.createCell(i);
			cell.setCellStyle(styles.get("header"));
			String  commentStr = commentList.get(i);
			if (!StringUtil.isEmpty(commentStr)){
				cell.setCellValue(headerList.get(i));
				Comment comment = this.sheet.createDrawingPatriarch().createCellComment(
						new XSSFClientAnchor(0, 0, 0, 0, (short) i, 0, (short) i+4, i+5));
				comment.setString(new XSSFRichTextString(commentStr));
				cell.setCellComment(comment);
			}else{
				cell.setCellValue(headerList.get(i));
			}
			sheet.autoSizeColumn(i);
		}
		for (int i = 0; i < headerList.size(); i++) {  
			int colWidth = sheet.getColumnWidth(i)*2;
	        sheet.setColumnWidth(i, colWidth < 3000 ? 3000 : colWidth);  
		}
		log.debug("Initialize success.");
	}
	
	/**
	 * 创建表格样式
	 * @param wb 工作薄对象
	 * @return 样式列表
	 */
	private Map<String, CellStyle> createStyles(Workbook wb) {
		Map<String, CellStyle> styles = new HashMap<String, CellStyle>();
		
		CellStyle style = wb.createCellStyle();
		style.setAlignment(CellStyle.ALIGN_CENTER);
		style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
		Font titleFont = wb.createFont();
		titleFont.setFontName("Arial");
		titleFont.setFontHeightInPoints((short) 16);
		titleFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
		style.setFont(titleFont);
		styles.put("title", style);

		style = wb.createCellStyle();
		style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
		style.setBorderRight(CellStyle.BORDER_THIN);
		style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
		style.setBorderLeft(CellStyle.BORDER_THIN);
		style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
		style.setBorderTop(CellStyle.BORDER_THIN);
		style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
		style.setBorderBottom(CellStyle.BORDER_THIN);
		style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
		Font dataFont = wb.createFont();
		dataFont.setFontName("Arial");
		dataFont.setFontHeightInPoints((short) 10);
		style.setFont(dataFont);
		styles.put("data", style);
		
		style = wb.createCellStyle();
		style.cloneStyleFrom(styles.get("data"));
		style.setAlignment(CellStyle.ALIGN_LEFT);
		styles.put("data1", style);

		style = wb.createCellStyle();
		style.cloneStyleFrom(styles.get("data"));
		style.setAlignment(CellStyle.ALIGN_CENTER);
		styles.put("data2", style);

		style = wb.createCellStyle();
		style.cloneStyleFrom(styles.get("data"));
		style.setAlignment(CellStyle.ALIGN_RIGHT);
		styles.put("data3", style);
		
		style = wb.createCellStyle();
		style.cloneStyleFrom(styles.get("data"));
//		style.setWrapText(true);
		style.setAlignment(CellStyle.ALIGN_CENTER);
		style.setFillForegroundColor(IndexedColors.GREY_50_PERCENT.getIndex());
		style.setFillPattern(CellStyle.SOLID_FOREGROUND);
		Font headerFont = wb.createFont();
		headerFont.setFontName("Arial");
		headerFont.setFontHeightInPoints((short) 10);
		headerFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
		headerFont.setColor(IndexedColors.WHITE.getIndex());
		style.setFont(headerFont);
		styles.put("header", style);
		
		return styles;
	}

	/**
	 * 添加一行
	 * @return 行对象
	 */
	public Row addRow(){
		return sheet.createRow(rownum++);
	}
	/**
	 * 添加一行
	 * @return 行对象
	 */
	public Row addRow(Sheet sheet,Integer rownum,String key){
		rownum++;
		rownums.put(key, rownum);
		return sheet.createRow(rownum);
	}
	

	/**
	 * 添加一个单元格
	 * @param row 添加的行
	 * @param column 添加列号
	 * @param val 添加值
	 * @return 单元格对象
	 */
	public Cell addCell(Row row, int column, Object val){
		return this.addCell(row, column, val, 0, Class.class);
	}
	
	/**
	 * 添加一个单元格
	 * @param row 添加的行
	 * @param column 添加列号
	 * @param val 添加值
	 * @param align 对齐方式（1：靠左；2：居中；3：靠右）
	 * @return 单元格对象
	 */
	public Cell addCell(Row row, int column, Object val, int align, Class<?> fieldType){
		Cell cell = row.createCell(column);
		CellStyle style = styles.get("data"+(align>=1&&align<=3?align:""));
		try {
			if (val == null){
				cell.setCellValue("");
			} else if (val instanceof String) {
				cell.setCellValue((String) val);
			} else if (val instanceof Integer) {
				cell.setCellValue((String) val);
			} else if (val instanceof Long) {
				cell.setCellValue((Long) val);
			} else if (val instanceof Double) {
				cell.setCellValue((Double) val);
			} else if (val instanceof Float) {
				cell.setCellValue((Float) val);
			} else if (val instanceof Date) {
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				cell.setCellValue(sdf.format(val));
			} else {
				if (fieldType != Class.class){
					cell.setCellValue((String)fieldType.getMethod("setValue", Object.class).invoke(null, val));
				}else{
					cell.setCellValue((String)Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(), 
						"fieldtype."+val.getClass().getSimpleName()+"Type")).getMethod("setValue", Object.class).invoke(null, val));
				}
			}
		} catch (Exception ex) {
			log.info("Set cell value ["+row.getRowNum()+","+column+"] error: " + ex.toString());
			cell.setCellValue(val.toString());
		}
		cell.setCellStyle(style);
		return cell;
	}

	/**
	 * 添加数据（通过annotation.ExportField添加数据）
	 * @return list 数据列表
	 */
	public <E> ExportExcel setDataList(Properties msgProp,List<E> list,Map map){
			for (E e : list){
				int colunm = 0;
				Row row = this.addRow();
				StringBuilder sb = new StringBuilder();
				for (Object[] os : annotationList){
					ExcelField ef = (ExcelField)os[0];
					Object val = null;
					// Get entity value
					try{
						if (StringUtils.isNotBlank(ef.value())){
							val = Reflections.invokeGetter(e, ef.value());
						}else{
							if (os[1] instanceof Field){
								val = Reflections.invokeGetter(e, ((Field)os[1]).getName());
							}else if (os[1] instanceof Method){
								val = Reflections.invokeMethod(e, ((Method)os[1]).getName(), new Class[] {}, new Object[] {});
							}
						}
						// If is dict, get dict label 
						if (StringUtils.isNotBlank(ef.dictType())){
							String valStr=val==null?"":val.toString();
							if("type".equals(ef.dictType()) || "attribute".equals(ef.dictType()) 
									|| "label".equals(ef.dictType())){
								// Get basic info
								val = getBasicInfo(ef.dictType(),map,valStr);
							}else{
								//字典数据已做国际化处理
								String dict=DictUtils.getDictLabel(ef.dictType(), valStr, "");
								//如果找不到字典国际化值，把字典本身作为默认值放进去，不然导出就是空了
								val = msgProp.getProperty(dict,dict);
							}
							
						}
					}catch(Exception ex) {
						// Failure to ignore
						log.error("Get entity value failed",ex);
						val = "";
					}
					this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
					sb.append(val + ", ");
				}
				log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString());
			}
		return this;
	}
	/**
	 * 添加数据（通过annotation.ExportField添加数据）
	 * @return list 数据列表
	 */
	public <E> ExportExcel setDataList(Properties msgProp, Map<String,List> dataMap, Map<Object,Object> map){
		Set<String> keyList=dataMap.keySet();
		for (String key : keyList) {
			List<E> list=dataMap.get(key);
			for (E e : list){
				int colunm = 0;
				Row row = this.addRow(sheets.get(key),rownums.get(key),key);
				StringBuilder sb = new StringBuilder();
				for (Object[] os : annotationMap.get(key)){
					ExcelField ef = (ExcelField)os[0];
					Object val = null;
					// Get entity value
					try{
						if (StringUtils.isNotBlank(ef.value())){
							val = Reflections.invokeGetter(e, ef.value());
						}else{
							if (os[1] instanceof Field){
								val = Reflections.invokeGetter(e, ((Field)os[1]).getName());
							}else if (os[1] instanceof Method){
								val = Reflections.invokeMethod(e, ((Method)os[1]).getName(), new Class[] {}, new Object[] {});
							}
						}
						// If is dict, get dict label 
						if (StringUtils.isNotBlank(ef.dictType())){
							String valStr=val==null?"":val.toString();
							if("type".equals(ef.dictType()) || "attribute".equals(ef.dictType()) 
									|| "label".equals(ef.dictType())){
								// Get basic info
								val = getBasicInfo(ef.dictType(),map,valStr);
							}else{
								//字典数据已做国际化处理
								String dict=DictUtils.getDictLabel(ef.dictType(), valStr, "");
								//如果找不到字典国际化值，把字典本身作为默认值放进去，不然导出就是空了
								val = msgProp.getProperty(dict,dict);
							}
							
						}
						if(ef.title().equals("is_hex") && !StringUtil.isEmpty(val)){
							Integer isHex=Integer.parseInt(val.toString());
							if(isHex.equals(0) || isHex.equals(2)){
								val = msgProp.getProperty("not_hex","not_hex");
							}else if(isHex.equals(1)){
								val = msgProp.getProperty("hex","hex");
							}else{
								val ="";
							}
						}
						if(ef.title().equals("is_case_insenstive") && !StringUtil.isEmpty(val)){
							Integer isCaseSenstive=Integer.parseInt(val.toString());
							if(isCaseSenstive.equals(0) || isCaseSenstive.equals(1)){
								val = msgProp.getProperty("case_insenstive","case_insenstive");
							}else if(isCaseSenstive.equals(1)){
								val = msgProp.getProperty("case_senstive","case_senstive");
							}else{
								val ="";
							}
						}
					}catch(Exception ex) {
						// Failure to ignore
						log.error("Get entity value failed",ex);
						val = "";
					}
					this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
					sb.append(val + ", ");
				}
				log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString());
			}
		}
		return this;
	}
	/**
	 * 添加数据（通过annotation.ExportField添加数据）
	 * @return list 数据列表
	 */
	public <E> ExportExcel setDataList(String columns,Properties msgProp,List<E> list,Map map){
		if(StringUtils.isBlank(columns)) {
			return setDataList(msgProp,list,map);
		}else {
			Map<String,Boolean> exportMap=new HashMap<>();
			String[] columnArray=columns.split(",");
			for (Object[] os : annotationList){
				ExcelField ef = (ExcelField)os[0];
				for(String column:columnArray) {
					if(column.equals(ef.title())) {
						exportMap.put(column, true);
						break;
					}
				}
			}
			for (E e : list){
				int colunm = 0;
				Row row = this.addRow();
				StringBuilder sb = new StringBuilder();
				for (Object[] os : annotationList){
					ExcelField ef = (ExcelField)os[0];
					if(exportMap.containsKey(ef.title())) {
						Object val = null;
						// Get entity value
						try{
							
							if (StringUtils.isNotBlank(ef.value())){
								val = Reflections.invokeGetter(e, ef.value());
							}else{
								if (os[1] instanceof Field){
									val = Reflections.invokeGetter(e, ((Field)os[1]).getName());
								}else if (os[1] instanceof Method){
									val = Reflections.invokeMethod(e, ((Method)os[1]).getName(), new Class[] {}, new Object[] {});
								}
							}
							// If is dict, get dict label 
							if (StringUtils.isNotBlank(ef.dictType())){
								String valStr=val==null?"":val.toString();
								if("type".equals(ef.dictType()) || "attribute".equals(ef.dictType()) 
										|| "label".equals(ef.dictType())){
									// Get basic info
									val = getBasicInfo(ef.dictType(),map,valStr);
								}else{
									//字典数据已做国际化处理
									String dict=DictUtils.getDictLabel(ef.dictType(), valStr, "");
									//如果找不到字典国际化值，把字典本身作为默认值放进去，不然导出就是空了
									val = msgProp.getProperty(dict,dict);
								}
								
							}
						}catch(Exception ex) {
							// Failure to ignore
							log.error("Get entity value failed",ex);
							val = "";
						}
						this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
						sb.append(val + ", ");
					}
				}
				log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString());
			}
		}
		return this;
	}
	/**
	 * 设置性质、分类、标签等信息
	 * @param dictType
	 * @param map
	 * @param val
	 * @return
	 */
	public String getBasicInfo(String dictType,Map map,String val) {
		String basicInfo="";
		List<ServiceDictInfo> list=new ArrayList<ServiceDictInfo>();
		if("type".equals(dictType)){
			list=(List<ServiceDictInfo>) map.get("fls");
			for (String info : val.split(",")) {
				for (ServiceDictInfo dictInfo : list) {
					if(info.equals(dictInfo.getServiceDictId().toString())){
						basicInfo+=","+dictInfo.getItemValue();
					}
				}
			}
			
		}
		if("attribute".equals(dictType)){
			list=(List<ServiceDictInfo>) map.get("xzs");
			for (String info : val.split(",")) {
				for (ServiceDictInfo dictInfo : list) {
					if(info.equals(dictInfo.getServiceDictId().toString())){
						basicInfo+=","+dictInfo.getItemValue();
					}
				}
			}
		}
		if("label".equals(dictType)){
			list=(List<ServiceDictInfo>) map.get("labels");
			for (String info : val.split(",")) {
				for (ServiceDictInfo dictInfo : list) {
					if(info.equals(dictInfo.getServiceDictId().toString())){
						basicInfo+=","+dictInfo.getItemValue();
					}
				}
			}
		}
		if(!StringUtil.isEmpty(basicInfo)){
			basicInfo=basicInfo.substring(1);
		}
		return basicInfo;
	}
	
	
	
	
	
	/************************************************************/
	/**
	 * 构造函数
	 * @param msgProp 国际化配置
	 * @param title sheet名称
	 * @param cls 实体对象，通过annotation.ExportField获取标题
	 * @param type 导出类型（1:导出数据；2：导出模板）
	 * @param groups 导入分组
	 * @return 
	 */
	public ExportExcel(Properties msgProp,List<String> titleList,Map<String,String> noExportMap,Map<String, Class<?>> clsMap, int type, int... groups){
		Map<String, List<String>> headerMap=new HashMap<String, List<String>>();
		Map<String, List<String>> commentMap=new HashMap<String, List<String>>();
		for (String title : titleList) {
			String noExportField=noExportMap.get(title);
			List<Object[]> annotationList = Lists.newArrayList();
			List<Field> list=new ArrayList<Field>();
			// Get annotation field 
			//递归获取cls实体对象及父级对象的属性
			getFields(list, clsMap.get(title).getClass());
			if(!StringUtil.isEmpty(list)){
				for (Field f : list){
					ExcelField ef = f.getAnnotation(ExcelField.class);
					if (ef != null && (ef.type()==0 || ef.type()==type)){
						if (groups!=null && groups.length>0){
							boolean inGroup = false;
							for (int g : groups){
								if (inGroup){
									break;
								}
								for (int efg : ef.groups()){
									if (g == efg){
										inGroup = true;
										if(!StringUtil.isEmpty(ef.title()) && !(noExportField.indexOf(","+ef.title()+",") > -1)){
											annotationList.add(new Object[]{ef, f});
										}
										break;
									}
								}
							}
						}else{
							if(!StringUtil.isEmpty(ef.title()) && !(noExportField.indexOf(","+ef.title()+",") > -1)){
								annotationList.add(new Object[]{ef, f});
							}
						}
					}
				}
			}
			List<Method> ms=new ArrayList<Method>();
			// Get annotation method
			//递归获取cls实体对象及父级对象的属性
			getMethods(ms, clsMap.get(title));
			if(!StringUtil.isEmpty(ms)){
				for (Method m : ms){
					ExcelField ef = m.getAnnotation(ExcelField.class);
					if (ef != null && (ef.type()==0 || ef.type()==type)){
						if (groups!=null && groups.length>0){
							boolean inGroup = false;
							for (int g : groups){
								if (inGroup){
									break;
								}
								for (int efg : ef.groups()){
									if (g == efg){
										inGroup = true;
										if(!StringUtil.isEmpty(ef.title()) && !(noExportField.indexOf(","+ef.title()+",") > -1)){
											annotationList.add(new Object[]{ef, m});
										}
										break;
									}
								}
							}
						}else{
							if(!StringUtil.isEmpty(ef.title()) && !(noExportField.indexOf(","+ef.title()+",") > -1)){
								annotationList.add(new Object[]{ef, m});
							}
							
						}
					}
				}
			}
			// Field sorting
			Collections.sort(annotationList, new Comparator<Object[]>() {
				public int compare(Object[] o1, Object[] o2) {
					return new Integer(((ExcelField)o1[0]).sort()).compareTo(
							new Integer(((ExcelField)o2[0]).sort()));
				};
			});
			// Initialize
			List<String> headerList = Lists.newArrayList();
			List<String> commentList = Lists.newArrayList();
			for (Object[] os : annotationList){
				String titleStr = ((ExcelField)os[0]).title();
				String commentStr = ((ExcelField)os[0]).comment();
				
				// 如果是导出，则去掉注释
				if (type==1){
					commentStr="";
				}
				if(!StringUtil.isEmpty(titleStr)){
					//去掉不需要展示的header
					if(!(noExportField.indexOf(","+titleStr+",") > -1)){
						titleStr=msgProp.getProperty(titleStr)==null?titleStr:msgProp.getProperty(titleStr);
						headerList.add(titleStr);
						commentList.add(commentStr);
					}
				}
			}
			headerMap.put(title, headerList);
			commentMap.put(title, commentList);
			annotationMap.put(title, annotationList);
		}
		initializeMultiSheet(msgProp,titleList, headerMap,commentMap);
	}
	
	/**
	 * 初始化函数
	 * @param title 表格标题，传“空值”，表示无标题
	 * @param headerList 表头列表
	 */
	private void initializeMultiSheet(Properties msgProp,List<String> titleList,Map<String, List<String>> headerMap,Map<String,List<String>> commentMap) {
		this.wb = new SXSSFWorkbook(500);
		int j=0;
		sheets=new HashMap<>();
		rownums=new HashMap<>();
		for (String title : titleList) {
			List<String> headerList=headerMap.get(title);
			List<String> commentList=commentMap.get(title);
			Sheet sheet = wb.createSheet(StringUtil.isEmpty(msgProp.get(title)) ? title:msgProp.get(title).toString());
			rownums.put(title, 0);
			sheets.put(title, sheet);
			this.styles = createStyles(wb);
			// Create header
			if (headerList == null){
				throw new RuntimeException("headerList not null!");
			}
			Integer rownum=rownums.get(title);
			Row headerRow = sheet.createRow(rownum++);
			headerRow.setHeightInPoints(16);
			for (int i = 0; i < headerList.size(); i++) {
				Cell cell = headerRow.createCell(i);
				cell.setCellStyle(styles.get("header"));
				String  commentStr = commentList.get(i);
				if (!StringUtil.isEmpty(commentStr)){
					cell.setCellValue(headerList.get(i));
					Comment comment = sheet.createDrawingPatriarch().createCellComment(
							new XSSFClientAnchor(0, 0, 0, 0, (short) i, 0, (short) i+4, 3));
					comment.setString(new XSSFRichTextString(commentStr));
					cell.setCellComment(comment);
				}else{
					cell.setCellValue(headerList.get(i));
				}
				sheet.autoSizeColumn(i);
			}
			for (int i = 0; i < headerList.size(); i++) {  
				int colWidth = sheet.getColumnWidth(i)*2;
				sheet.setColumnWidth(i, colWidth < 3000 ? 3000 : colWidth);  
			}
			j++;
		}
		log.debug("Initialize success.");
	}
	
	
	
	
	/**
	 * 输出数据流
	 * @param os 输出数据流
	 */
	public ExportExcel write(OutputStream os) throws IOException{
		wb.write(os);
		return this;
	}
	
	/**
	 * 输出到客户端
	 * @param fileName 输出文件名
	 */
	public ExportExcel write(HttpServletResponse response, String fileName) throws IOException{
		response.reset();
        response.setContentType("application/octet-stream; charset=utf-8");
        response.setHeader("Content-Disposition", "attachment; filename="+Encodes.urlEncode(fileName));
		write(response.getOutputStream());
		return this;
	}
	
	/**
	 * 输出到文件
	 * @param fileName 输出文件名
	 */
	public ExportExcel writeFile(String name) throws FileNotFoundException, IOException{
		FileOutputStream os = new FileOutputStream(name);
		this.write(os);
		return this;
	}
	/**
	 * 输出到客户端
	 * @param fileName 输出文件名
	 */
	public ExportExcel write(HttpServletRequest request,HttpServletResponse response, String fileName) throws IOException{
		
		final String userAgent = request.getHeader("USER-AGENT");  
        String finalFileName = null;  
        if(StringUtils.contains(userAgent, "MSIE")){//IE浏览器  
	        finalFileName = Encodes.urlEncode(fileName);  
	    }else if(StringUtils.contains(userAgent, "Mozilla")){//google,火狐浏览器  
	        finalFileName = new String(fileName.getBytes(), "ISO8859-1");  
	    }else{  
	        finalFileName = Encodes.urlEncode(fileName);//其他浏览器  
	    }
		
		response.reset();
        response.setContentType("application/octet-stream; charset=utf-8");
        response.setHeader("Content-Disposition", "attachment; filename="+finalFileName);
		write(response.getOutputStream());
		return this;
	}
	/**
	 * 清理临时文件
	 */
	public ExportExcel dispose(){
		wb.dispose();
		return this;
	}
	
	/**
	 * 导出测试
	 */
	public static void main(String[] args) throws Throwable {
		
		/*List<String> headerList = Lists.newArrayList();
		for (int i = 1; i <= 10; i++) {
			headerList.add("表头"+i);
		}
		
		List<String> dataRowList = Lists.newArrayList();
		for (int i = 1; i <= headerList.size(); i++) {
			dataRowList.add("数据"+i);
		}
		
		List<List<String>> dataList = Lists.newArrayList();
		for (int i = 1; i <=1000000; i++) {
			dataList.add(dataRowList);
		}

		ExportExcel ee = new ExportExcel("表格标题", headerList);
		
		for (int i = 0; i < dataList.size(); i++) {
			Row row = ee.addRow();
			for (int j = 0; j < dataList.get(i).size(); j++) {
				ee.addCell(row, j, dataList.get(i).get(j));
			}
		}
		
		ee.writeFile("target/export.xlsx");

		ee.dispose();
		
		log.debug("Export success.");
		*/
	}

}