Java生成操作excel(超详细,例如xml文件生成excel)

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;

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 jxl.Workbook;
import jxl.format.Alignment;
import jxl.format.Border;
import jxl.format.BorderLineStyle;
import jxl.read.biff.BiffException;
import jxl.write.Label;
import jxl.write.WritableCellFormat;
import jxl.write.WritableFont;
import jxl.write.WritableImage;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;

public class ExcelUtil {
	private static WritableSheet sheet = null;
	private static WritableSheet sheetToMap = null;
	private static WritableSheet sheetToMerge = null;
	private static Workbook rwork = null ;
    	private static WritableWorkbook wwb = null ;
    	private static Map<String,String> indexMap = null ;
	
	/**
	 * @param 用来代替传统的使用IReport生成Excel 
	 * @param jxl操作excel1
	 * @param 只替换Paremeter的值
	 * @param 2012-03-23
	 * @param List的值和顺序完全按照Bean的属性和值来排列的，如果需要修改排列顺序，那么请修改Bean属性的排列顺序
	 * @param String realPath 			:读取模版路径
	 * @param String outPath 			:输出模版路径
	 * @param Map<String,String> map	:需要替换的Parameter
	 * @return
	 * */
	public static void jExcelTemplate(String realPath,Map<String,String> map,HttpServletResponse response) {
		try {
			jxlDocTemplateAll(realPath,map,null,0,0,null,null,response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * @param 用来代替传统的使用IReport生成Excel
	 * @param jxl操作excel1
	 * @param 只替换List的值
	 * @param List的值和顺序完全按照Bean的属性和值来排列的，如果需要修改排列顺序，那么请修改Bean属性的排列顺序
	 * @param 需要设置坐标，即List循环的起始坐标
	 * @param 2012-03-23
	 * @param String realPath 			:读取模版路径
	 * @param String outPath 			:输出模版路径
	 * @param List<?> list				:循环任意类型的List
	 * @param list可以没有指定的泛型，但必须是指定的Model
	 * @param list必须要指定初始化的坐标
	 * @return
	 * */
	public static void jExcelTemplate(String realPath,List<?> list,int x,int y,HttpServletResponse response) {
		try {
			jxlDocTemplateAll(realPath,null,list,x,y,null,null,response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * @param 用来代替传统的使用IReport生成Excel
	 * @param jxl操作excel1
	 * @param 2012-03-23
	 * @param 替换Paremeter和List的值
	 * @param Paremeter即传如的Map<String,String>，且必须的String类型的
	 * @param Paremeter必须且最少有一个和模版上的值对应上，否则会报错
	 * @param List的值和顺序完全按照Bean的属性和值来排列的，如果需要修改排列顺序，那么请修改Bean属性的排列顺序
	 * @param 需要设置坐标，即List循环的起始坐标
	 * @param String realPath 			:读取模版路径
	 * @param String outPath 			:输出模版路径
	 * @param Map<String,String> map	:需要替换的Parameter
	 * @param List<?> list				:循环任意类型的List
	 * @param list可以没有指定的泛型，但必须是指定的Model
	 * @param list必须要指定初始化的坐标
	 * @return
	 * */
	public static void jExcelTemplate(String realPath,Map<String,String> map,List<?> list,int x,int y,HttpServletResponse 	response) {
		try {
			jxlDocTemplateAll(realPath,map,list,x,y,null,null,response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * @param 用来代替传统的使用IReport生成Excel
	 * @param jxl操作excel1
	 * @param 2012-03-23
	 * @param 替换Paremeter和List的值，指定合并的单元格
	 * @param Paremeter即传如的Map<String,String>，且必须的String类型的
	 * @param Paremeter必须且最少有一个和模版上的值对应上，否则会报错
	 * @param List的值和顺序完全按照Bean的属性和值来排列的，如果需要修改排列顺序，那么请修改Bean属性的排列顺序
	 * @param 需要设置坐标，即List循环的起始坐标
	 * @param String realPath 			:读取模版路径
	 * @param String outPath 			:输出模版路径
	 * @param Map<String,String> map	:需要替换的Parameter
	 * @param List<?> list				:循环任意类型的List
	 * @param list可以没有指定的泛型，但必须是指定的Model
	 * @param list必须要指定初始化的坐标
	 * @param 允许合并多个单元格，并且属性是居中，自动换行的
	 * @param 合并的单元格如果想替换成指定内容，需要对传入的List<JXLExcelModel> 中 JXLExcelModel.mergeText赋值
	 * @return
	 * */
	public static void jExcelTemplate(String realPath,Map<String,String> map,List<?> list,int x,int y,List<JXLExcelModel> 	jxlList,HttpServletResponse response) {
		try {
			jxlDocTemplateAll(realPath,map,list,x,y,jxlList,null,response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * @param 用来代替传统的使用IReport生成Excel
	 * @param jxl操作excel1
	 * @param 2012-03-23
	 * @param 替换Paremeter和List的值，指定合并的单元格
	 * @param Paremeter即传如的Map<String,String>，且必须的String类型的
	 * @param Paremeter必须且最少有一个和模版上的值对应上，否则会报错
	 * @param List的值和顺序完全按照Bean的属性和值来排列的，如果需要修改排列顺序，那么请修改Bean属性的排列顺序
	 * @param 需要设置坐标，即List循环的起始坐标
	 * @param String realPath 			:读取模版路径
	 * @param String outPath 			:输出模版路径
	 * @param Map<String,String> map	:需要替换的Parameter
	 * @param List<?> list				:循环任意类型的List
	 * @param list可以没有指定的泛型，但必须是指定的Model
	 * @param list必须要指定初始化的坐标
	 * @param 允许合并多个单元格，并且属性是居中，自动换行的
	 * @param 合并的单元格如果想替换成指定内容，需要对传入的List<JXLExcelModel> 中 JXLExcelModel.mergeText赋值
	 * @return
	 * */
	public static void jExcelTemplate(String realPath,Map<String,String> map,List<?> list,int x,int y,List<JXLExcelModel> 	jxlList,int[][] mergeInt,HttpServletResponse response) {
		try {
			jxlDocTemplateAll(realPath,map,list,x,y,jxlList,mergeInt,response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * @param 用来代替传统的使用IReport生成Excel
	 * @param jxl操作excel1
	 * @param 操作List,Map,合并单元格，合并单元格填充的值
	 * @param List的值和顺序完全按照Bean的属性和值来排列的，如果需要修改排列顺序，那么请修改Bean属性的排列顺序
	 * @param String realPath 			:读取模版路径
	 * @param String outPath 			:输出模版路径
	 * @param Map<String,String> map	:需要替换的Parameter
	 * @param List<?> list				:循环任意类型的List
	 * @param list可以没有指定的泛型，但必须是指定的Model
	 * @param list必须要指定初始化的坐标
	 * @param 允许合并多个单元格，并且属性是居中，自动换行的
	 * @param 合并的单元格如果想替换成指定内容，需要对传入的List<JXLExcelModel> 中 JXLExcelModel.mergeText赋值
	 * @return
	 * */
	public static void jExcelTemplate(String realPath,Map<String,String> map,List<?> list,List<JXLExcelModel> 	jxlList,HttpServletResponse response) {
		try {
			jxlDocTemplateAllMoreList(realPath,map,list,jxlList,null,response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * @param 用来代替传统的使用IReport生成Excel
	 * @param jxl操作excel1
	 * @param 操作List,Map,合并单元格，合并单元格填充的值
	 * @param List的值和顺序完全按照Bean的属性和值来排列的，如果需要修改排列顺序，那么请修改Bean属性的排列顺序
	 * @param String realPath 			:读取模版路径
	 * @param String outPath 			:输出模版路径
	 * @param Map<String,String> map	:需要替换的Parameter
	 * @param List<?> list				:循环任意类型的List
	 * @param list可以没有指定的泛型，但必须是指定的Model
	 * @param list必须要指定初始化的坐标
	 * @param 允许合并多个单元格，并且属性是居中，自动换行的
	 * @param 合并的单元格如果想替换成指定内容，需要对传入的List<JXLExcelModel> 中 JXLExcelModel.mergeText赋值
	 * @param int[][] mergeInt 			:对指定列的上下行进行合并
	 * @return
	 * */
	public static void jExcelTemplate(String realPath,Map<String,String> map,List<?> list,List<JXLExcelModel> jxlList,int[]	[] mergeInt,HttpServletResponse response) {
		try {
			jxlDocTemplateAllMoreList(realPath,map,list,jxlList,mergeInt,response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/* 
	 * 2012-03-23
	 * 这个方法能遍历多个List表格
	 * */
	@SuppressWarnings("unchecked")
	public static void jxlDocTemplateAllMoreList(String realPath,Map<String,String> map,List<?> list,List<JXLExcelModel> 	jxlList,int[][] mergeInt,HttpServletResponse response) throws WriteException {
		try {
			String outPath = realPath.substring(0, realPath.length() - 4) + "_bak.xls" ;
			boolean merge = false ;  //判断是否有单元格要进行合并
			if(jxlList != null) {
				merge = true ;
			}
			if(fileExist(realPath)) {
				//1.找到模版文件并加载
				HSSFWorkbook rwb = new HSSFWorkbook(new FileInputStream(realPath)) ;

				//2.得到要修改的Parameter，并记录坐标  开始-------------------------
				HSSFSheet sht = rwb.getSheetAt(0) ;
				Map<String,String> indexMap = new HashMap<String,String>() ;
				/*
				 * 判断是否有需要替换的Paremeter
				 * 通过map来遍历得到要替换对象在excel中的坐标并保存在(indexMap)坐标map中
				 * 格式 x|y
				 * */
				if(map != null) {
					String indexList = "" ;
					for(String value:map.keySet()) {//遍历是否存在要替换的Parameter坐标，并记录在Map中  格式：  x|y  
						try {
							indexList = getCellindex(sht, value) ;
							//cell = getCellindex(sht, value);
						} catch(java.lang.RuntimeException e) {
							continue ;
						}
						indexMap.put(value, indexList) ;
					}
				}
				//2.得到要修改的Parameter，并记录坐标  结束-------------------------
				
				//3.读取Excel模版文件，加载到WritableWorkbook中，使其允许修改操作
				rwork = Workbook.getWorkbook(new File(realPath)) ;  //读取模版文件
		        wwb = Workbook.createWorkbook(new FileOutputStream(outPath),rwork) ; //修改模版
		        
				//4.读取工作表
				WritableSheet sheet = wwb.getSheet(0) ;
				//查找工作表，如果没有获得相应工作表，先创建一个名为test的工作表
				if(sheet == null) {
					sheet = wwb.createSheet("test", 0) ;
				}
				if(map != null) {
					//5.先替换模版中的Parameter值  开始 ---------------------------------------------
					for(String value:indexMap.keySet()) {
						int x = Integer.parseInt(indexMap.get(value).split("#")[0]) ;
						int y = Integer.parseInt(indexMap.get(value).split("#")[1]) ;
						WritableCellFormat wc1 = new WritableCellFormat();
			            wc1.setAlignment(Alignment.CENTRE); // 设置居中
			            wc1.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
			            wc1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
			            Label label01 = null ;
			            label01 = new Label(y,x,map.get(value),wc1) ;
						sheet.addCell(label01) ;
					}
					//5.先替换模版中的Parameter值  结束 ---------------------------------------------
				}
				/*
				 * 6.通过list循环插入列值  开始---------------------------------------------
				 * 通过反射来得到List对象的属性和值
				 * */
					if(list != null) {
						for(int listSi = 0 ; listSi < list.size() - 2 ; listSi += 3 ) {
							List<Object> listValue = ReflectUtil.getAllFieldAndValue((List<Object>)list.get(listSi)) ;
				    		List<Object[]> dataValueList = (List<Object[]>) listValue.get(2) ;
							for(int i = 0 ; i < dataValueList.size() ; i ++ ) {
								WritableCellFormat wc2 = new WritableCellFormat();
					            wc2.setAlignment(Alignment.CENTRE); // 设置居中
					            wc2.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
					            wc2.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
					            int iii = Integer.parseInt(list.get(listSi + 2 ).toString()) ;
					            int www = Integer.parseInt(list.get(listSi + 1 ).toString()) ;
					            sheet.insertRow(iii) ; //在指定位置插入一新行，用以插入数据
					            Label label02 = null ;
					            Object[] object = dataValueList.get(i) ;
					    		for(int num = 0 ; num < object.length ; num ++ ) {
					    			String value = "" ;
					    			if(object[num] != null ) {
					    				value = object[num].toString() ;
					    			}
					    			label02 =  new Label(www + num , iii, value ,wc2) ;
					    			sheet.addCell(label02) ;
					    		}
					    		www += 1 ;
							}
						}
					}
					//6.通过list循环插入列值  结束---------------------------------------------
					
					//7.对指定单元格进行合并  开始-----------------------------------------
					if(merge) {
						JXLExcelModel jxlModel = null ;
						for(int jj = 0 ; jj < jxlList.size() ; jj ++ ) {
							WritableCellFormat wc3 = new WritableCellFormat();
				            wc3.setAlignment(Alignment.CENTRE); // 设置居中
				            wc3.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
				            wc3.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
				            wc3.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
				            wc3.setWrap(true) ;  //设置单元格属性为自动换行
				            jxlModel = jxlList.get(jj) ; 
				            sheet.mergeCells(jxlModel.getStartX(), jxlModel.getStartY(), jxlModel.getEndX(), jxlModel.getEndY());
				            /*
				             * 如果有单元格进行合并，判断是否有需要填充的值
				             * */
				            if(jxlModel.getMergeText() != null) {
				            	sheet.addCell(new Label(jxlModel.getStartX(),jxlModel.getStartY(),jxlModel.getMergeText(),wc3)) ;
				            }
						}
					}
					//7.对指定样式进行合并  结束-----------------------------------------
					//response.wait(wwb) ;
		    		try {
		    			//8.将编辑好的Excel存放到输出到指定的目录下
		    			wwb.write() ;
		    		} catch(java.lang.ArrayIndexOutOfBoundsException e) {
		    			System.out.println("线程异常") ;
		    		}
				} else {
				System.out.println("模版文件不存在 !!!") ;
			}
		} catch(Exception e) {
			System.out.println(e) ;
		} finally {
			//9.关闭wwb,以释放内存
    		if(rwork != null) {
	    		rwork.close() ;
    		}
    		if(wwb != null) {
				try {
					wwb.close() ;
				} catch (WriteException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
    		}
    		
    		String outPath = realPath.substring(0, realPath.length() - 4) + "_bak.xls" ;
			HSSFWorkbook rwb2 = null ;
			//8.对指定列进行上下行合并   开始----------------------------------------------------------
			if(mergeInt != null && list.size() > 0) {
				try {
					rwb2 = new HSSFWorkbook(new FileInputStream(outPath));
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
				HSSFSheet sht2 = rwb2.getSheetAt(0) ;
				HSSFRow rows = null ;
				HSSFCell cl = null ;
				HSSFRow rows2 = null ;
				HSSFCell cl2 = null ;
				Workbook rwork2 = null ;
				WritableWorkbook wwb2 = null ;
				try {
					rwork2 = Workbook.getWorkbook(new File(outPath)) ;
				} catch (BiffException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}  //读取模版文件
				try {
					wwb2 = Workbook.createWorkbook(new FileOutputStream(outPath),rwork2) ;
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				} //修改模版
				WritableSheet sheet2 = wwb2.getSheet(0) ;
				WritableCellFormat wc4 = new WritableCellFormat();
				wc4.setAlignment(Alignment.CENTRE);
				wc4.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
		        wc4.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
		        wc4.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
		        wc4.setWrap(true) ;  //设置单元格属性为自动换行
				for(int mergeM = 0 ; mergeM < mergeInt.length ; mergeM ++ ) {
					int maxMergeInt = 0 ;
					for(int mergeMin = mergeInt[mergeM][1] ; mergeMin < (mergeInt[mergeM][1] + mergeInt[mergeM][2]) - 1 ;) {
						//这里是指定行
						rows = sht2.getRow(mergeMin) ;  //rows得到当前行的数据
						if(rows == null) {
							continue ;
						} else {
							cl = rows.getCell(mergeInt[mergeM][0]) ;
							maxMergeInt = 1 ;
							//从本行起开始遍历行，一直到和本行值不一样为止
							for(int maxMergeIntSize = mergeMin ; maxMergeIntSize < (mergeInt[mergeM][1] + mergeInt[mergeM][2]) - 1 ; maxMergeIntSize ++ ) {
								//循环到下N行，如果本行的值是相同的;
								rows2 = sht2.getRow(mergeMin + maxMergeInt) ;
								cl2 = rows2.getCell(mergeInt[mergeM][0]) ;
								if(cl != null && cl2 != null) {
									if(!cl.getRichStringCellValue().toString().equals("") && cl.getRichStringCellValue().toString().trim().equals(cl2.getRichStringCellValue().toString().trim())) {
										maxMergeInt ++ ;
									} else {
										break ;
									}
								}
							}
							rows2 = sht2.getRow(mergeMin + maxMergeInt - 1) ;
							cl2 = rows2.getCell(mergeInt[mergeM][0]) ;
							if(cl != null && cl2 != null) {
								if(!cl.getRichStringCellValue().toString().equals("") && cl.getRichStringCellValue().toString().trim().equals(cl2.getRichStringCellValue().toString().trim())) {
									//如果列的上下行相等，得到X，Y坐标，并进行合并
						            try {
								            sheet2.mergeCells(mergeInt[mergeM][0], mergeMin, mergeInt[mergeM][0], mergeMin + maxMergeInt - 1) ;
								            sheet2.addCell(new Label(mergeInt[mergeM][0], mergeMin - 1 ,cl2.getRichStringCellValue().toString(),wc4)) ;
									} catch (WriteException e) {
										e.printStackTrace();
									} // 设置居中
								} else {
								}
							}
						}
						 mergeMin += maxMergeInt ;
					}
				}
				try {
					wwb2.write() ;
					rwork2.close() ;
					try {
						wwb2.close() ;
					} catch (WriteException e) {
						e.printStackTrace();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			//8.通过流实现文件下载
    		try {
    			//response = ServletActionContext.getResponse();
    			//String path = getRequest().getParameter("fileName");
    			// path是指欲下载的文件的路径。
    			File file = new File(outPath);
    			// 取得文件名。
    			String filename = file.getName();
    			// 以流的形式下载文件。
    			InputStream fis = new BufferedInputStream(new FileInputStream(outPath));
    			byte[] buffer = new byte[fis.available()];
    			fis.read(buffer);
    			fis.close();
    			// 清空response
    			response.reset();
    			// 设置response的Header
    			response.setHeader("Content-Type", "application/octet-stream");
    			response.addHeader("Content-Disposition", "attachment;filename=" + new String(filename.getBytes(), "ISO8859-1"));
    			response.addHeader("Content-Length", "" + file.length());
    			// response.setContentType("application/octet-stream");
    			OutputStream toClient = response.getOutputStream();
    			toClient.write(buffer);
    			toClient.flush();
    			toClient.close();
    		} catch (IOException ex) {
    			System.out.println(ex) ;
    		}
		}
	}
	
	/* 
	 * 
	 * 2012-03-29
	 * 这个方法只能遍历一个List表格
	 * 其中
	 * 		1.1
	 * 		1.3.2
	 * 待优化
	 * */
	@SuppressWarnings("unchecked")
	public static void jxlDocTemplateAll(String realPath,Map<String,String> map,List<?> list,int listX,int listY,List<JXLExcelModel> jxlList,int[][] mergeInt,HttpServletResponse response) throws WriteException {
		//1：读取Excel模版文件，加载到WritableWorkbook中         开始 ----------------------------------------
		try {
			//1.1：设置输出模版的文件名，以_bak.xls结尾（待优化）
			String outPath = realPath.substring(0, realPath.length() - 4) + "_bak.xls" ;
			//1.2: 判断是否有单元格要进行合并   开始-----------------------------
			boolean merge = false ;
			if(jxlList != null) {
				/*	List<JXLExcelModel> jxlList
					JXLExcelModel这个Model中设置需要
						合并单元格的起始X轴
						合并单元格的起始Y轴
						合并单元格的结束X轴
						合并单元格的结束Y轴
				*/
				merge = true ;
			}
			//1.2: 判断是否有单元格要进行合并   结束-----------------------------
			
			//1.3: 判断文件是否存在，如果存在才进行操作 
			if(fileExist(realPath)) {
				//1.3.1 找到模版文件并加载，HSSFWorkbook只能读取，不能修改
				HSSFWorkbook rwb = new HSSFWorkbook(new FileInputStream(realPath)) ;
				//1.3.2 得到模版中的工作表（待优化），本文只能对模版中的第一个工作表进行修改，应该设置为可配置项
				HSSFSheet sht = rwb.getSheetAt(0) ;
				//1.3.3 初始化Map indexMap ， 用来存储需要合并的单元格的坐标
				Map<String,String> indexMap = null ;
				/* 1.3.4 
				 * 判断是否有需要替换的Paremeter  开始-------------------------------
				 * 通过map来遍历得到要替换对象在excel中的坐标并保存在(indexMap)坐标map中
				 * 格式 x|y
				 * */
				if(map != null) {
					indexMap = new HashMap<String,String>() ;
					String indexList = "" ;
					for(String value:map.keySet()) {//遍历是否存在要替换的Parameter坐标，并记录在Map中  格式：  x|y  
						try {
							//1.3.5 通过方法getCellindex(工作表,要比较的值) 得到在excel中详细坐标的核心方法
							indexList = getCellindex(sht, value) ;
						} catch(java.lang.RuntimeException e) {
							continue ;
						}
						//1.3.6 向indexMap插入得到的值
						indexMap.put(value, indexList) ;
					}
				}
				// 1.3.4 判断是否有需要替换的Paremeter  结束-------------------------------
				
				// 1.4.1 Workbook rwork 读取的模版只能读取不能修改
				rwork = Workbook.getWorkbook(new File(realPath)) ;  //读取模版文件
				// 1.4.2 WritableWorkbook wwb 通过创建WritableWorkbook，并加载rwork 来实现修改EXCEL的操作
				wwb = Workbook.createWorkbook(new FileOutputStream(outPath),rwork) ; //修改模版
				//1.4.3 读取工作表
				WritableSheet sheet = wwb.getSheet(0) ;
				//1.4.4 查找工作表，如果没有获得相应工作表，先创建一个名为test的工作表
				if(sheet == null) {
					sheet = wwb.createSheet("test", 0) ;
				}
				//1.5 判断是否有需要替换的字段，如果有，进行替换操作   开始 ------------------------------------------
				if(map != null) {
					//1.5.1 先替换模版中的Parameter值  开始 ---------------------------------------------
					WritableCellFormat wc1 = new WritableCellFormat();
					//wc1.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
					//wc1.setBackground(jxl.format.Colour.BLACK); // 设置单元格的背景颜色
		            wc1.setAlignment(Alignment.CENTRE); // 设置居中
		           // wc1.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
		            wc1.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
		            wc1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
					for(String value:indexMap.keySet()) {
						//得到x轴坐标
						int x = Integer.parseInt(indexMap.get(value).split("#")[0]) ;
						//得到y轴坐标
						int y = Integer.parseInt(indexMap.get(value).split("#")[1]) ;
			            //wc.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
			            //wc.setBackground(jxl.format.Colour.BLACK); // 设置单元格的背景颜色
			            //WritableFont wfont = new WritableFont(WritableFont.createFont("宋体"), 14);
			            //WritableCellFormat font = new WritableCellFormat(wfont);
			            Label label01 = null ;
			            label01 = new Label(y,x,map.get(value),wc1) ;
						sheet.addCell(label01) ;
					}
					//1.5.1 先替换模版中的Parameter值  结束 ---------------------------------------------
				}
				//1.5 判断是否有需要替换的字段，如果有，进行替换操作   结束 ------------------------------------------
				
				//1.6 通过list循环插入列值  开始-------------------------------------------------------------------
					if(list != null && list.size() > 0) {
						//1.6.1 通过反射得到list的所有列和值，并返回一个二维数组的list， list[0]返回类型  list[1]返回get方法  list[2]返回值
						List<Object> listValue = ReflectUtil.getAllFieldAndValue(list) ;
						//1.6.2 只要返回值的list
			    		List<Object[]> dataValueList = (List<Object[]>) listValue.get(2) ;
			    		WritableCellFormat wc2 = new WritableCellFormat();
			            wc2.setAlignment(Alignment.CENTRE); // 设置居中
			            wc2.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
			            wc2.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
			            wc2.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
			            wc2.setWrap(true) ;  //设置单元格属性为自动换行
						for(int i = 0 ; i < dataValueList.size() ; i ++ ) {
				            sheet.insertRow(listY) ; //在指定位置插入一新行，用以插入数据
				            Label label02 = null ;
				            Object[] object = dataValueList.get(i) ;
				    		for(int num = 0 ; num < object.length ; num ++ ) {
				    			String value = "" ;
				    			if(object[num] != null ) {
				    				value = object[num].toString() ;
				    			}
				    			label02 =  new Label(listX + num , listY, value ,wc2) ;
				    			sheet.addCell(label02) ;
				    		}
							listY += 1 ;
						}
					}
					//1.6 通过list循环插入列值  结束---------------------------------------------
					
					//1.7 对指定单元格进行合并  开始-----------------------------------------
					if(merge) {
						JXLExcelModel jxlModel = null ;
						WritableCellFormat wc3 = new WritableCellFormat() ;
						wc3.setAlignment(Alignment.CENTRE); // 设置居中
			            wc3.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
			            wc3.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
			            wc3.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
			            wc3.setWrap(true) ;  //设置单元格属性为自动换行
						for(int jj = 0 ; jj < jxlList.size() ; jj ++ ) {
							//sheet.mergeCells(0, 5, 0, (5 + getList().size()));
				            jxlModel = jxlList.get(jj) ; 
				            sheet.mergeCells(jxlModel.getStartX(), jxlModel.getStartY(), jxlModel.getEndX(), jxlModel.getEndY());
				            /*
				             * 如果有单元格进行合并，判断是否有需要填充的值
				             * */
				            if(jxlModel.getMergeText() != null) {
				            	sheet.addCell(new Label(jxlModel.getStartX(),jxlModel.getStartY(),jxlModel.getMergeText(),wc3)) ;
				            }
						}
					}
					//1.7 对指定样式进行合并  结束-----------------------------------------
					
		    		try {
		    			wwb.write() ;
		    		} catch(java.lang.ArrayIndexOutOfBoundsException e) {
		    			System.out.println("线程异常") ;
		    		}
				} else {
				System.out.println("模版文件不存在 !!!") ;
			}
		} catch(Exception e) {
			System.out.println(e) ;
		} finally {
			//9.关闭wwb,以释放内存
    		if(rwork != null) {
	    		rwork.close() ;
    		}
    		if(wwb != null) {
				try {
					wwb.close() ;
				} catch (WriteException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
    		}
    		
    		String outPath = realPath.substring(0, realPath.length() - 4) + "_bak.xls" ;
			HSSFWorkbook rwb2 = null ;
			//8.对指定列进行上下行合并   开始----------------------------------------------------------
			if(mergeInt != null && list.size() > 0) {
				try {
					rwb2 = new HSSFWorkbook(new FileInputStream(outPath));
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
				HSSFSheet sht2 = rwb2.getSheetAt(0) ;
				HSSFRow rows = null ;
				HSSFCell cl = null ;
				HSSFRow rows2 = null ;
				HSSFCell cl2 = null ;
				Workbook rwork2 = null ;
				WritableWorkbook wwb2 = null ;
				try {
					rwork2 = Workbook.getWorkbook(new File(outPath)) ;
				} catch (BiffException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}  //读取模版文件
				try {
					wwb2 = Workbook.createWorkbook(new FileOutputStream(outPath),rwork2) ;
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				} //修改模版
				WritableSheet sheet2 = wwb2.getSheet(0) ;
				WritableCellFormat wc4 = new WritableCellFormat();
				wc4.setAlignment(Alignment.CENTRE);
				wc4.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
		        wc4.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
		        wc4.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
		        wc4.setWrap(true) ;  //设置单元格属性为自动换行
		        //一列合并 {0,4,350} 0:列  1:行  2:长度
				for(int mergeM = 0 ; mergeM < mergeInt.length ; mergeM ++ ) {//合并列数
					int maxMergeInt = 0 ;
					for(int mergeMin = mergeInt[mergeM][1] ; mergeMin < (mergeInt[mergeM][1] + mergeInt[mergeM][2]) - 1 ; ) {//一列一列执行
						//这里是指定行
						rows = sht2.getRow(mergeMin) ;  //rows得到当前行的数据
						if(rows == null) {
							continue ;
						} else {
							cl = rows.getCell(mergeInt[mergeM][0]) ;//{0,4,350}
							maxMergeInt = 1 ;
							//从本行起开始遍历行，一直到和本行值不一样为止
							for(int maxMergeIntSize = mergeMin ; maxMergeIntSize < (mergeInt[mergeM][1] + mergeInt[mergeM][2]) - 1 ; maxMergeIntSize ++ ) {
								//循环到下N行，如果本行的值是相同的;
								rows2 = sht2.getRow(mergeMin + maxMergeInt) ;
								cl2 = rows2.getCell(mergeInt[mergeM][0]) ;
								if(cl != null && cl2 != null) {
									if(!cl.getRichStringCellValue().toString().equals("") && cl.getRichStringCellValue().toString().trim().equals(cl2.getRichStringCellValue().toString().trim())) {
										maxMergeInt ++ ;
									} else {
										continue ;
									}
								}
							}
							rows2 = sht2.getRow(mergeMin + maxMergeInt - 1) ;
							cl2 = rows2.getCell(mergeInt[mergeM][0]) ;
							if(cl != null && cl2 != null) {
								if(!cl.getRichStringCellValue().toString().equals("") && cl.getRichStringCellValue().toString().trim().equals(cl2.getRichStringCellValue().toString().trim())) {
									//如果列的上下行相等，得到X，Y坐标，并进行合并
						            try {
							            sheet2.mergeCells(mergeInt[mergeM][0], mergeMin, mergeInt[mergeM][0], mergeMin + maxMergeInt - 1) ;
							            sheet2.addCell(new Label(mergeInt[mergeM][0], mergeMin ,cl2.getRichStringCellValue().toString(),wc4)) ;
									} catch (WriteException e) {
										e.printStackTrace();
									} // 设置居中
								} else {
								}
							}
						}
						 mergeMin += maxMergeInt ;
					}
				}
				try {
					wwb2.write() ;
					rwork2.close() ;
					try {
						wwb2.close() ;
					} catch (WriteException e) {
						e.printStackTrace();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			//8.通过流实现文件下载
    		try {
    			//response = ServletActionContext.getResponse();
    			//String path = getRequest().getParameter("fileName");
    			// path是指欲下载的文件的路径。
    			File file = new File(outPath);
    			// 取得文件名。
    			String filename = file.getName();
    			// 以流的形式下载文件。
    			InputStream fis = new BufferedInputStream(new FileInputStream(outPath));
    			byte[] buffer = new byte[fis.available()];
    			fis.read(buffer);
    			fis.close();
    			// 清空response
    			response.reset();
    			// 设置response的Header
    			response.setHeader("Content-Type", "application/octet-stream");
    			response.addHeader("Content-Disposition", "attachment;filename=" + new String(filename.getBytes(), "ISO8859-1"));
    			response.addHeader("Content-Length", "" + file.length());
    			// response.setContentType("application/octet-stream");
    			OutputStream toClient = response.getOutputStream();
    			toClient.write(buffer);
    			toClient.flush();
    			toClient.close();
    		} catch (IOException ex) {
    			System.out.println(ex) ;
    		}
		}
	}
	
	/*
	 //1 	测试用的2003版excel文档路径
			String filePath = "C:\\temp\\test.xls" ;
			//2 模拟生成List<?>
			List<?> list = com.JXLTestMain.getTestList1() ;
			//将参数传入JXL处理类中生成新的Excel
				/*
				 * 设立 JXLListModel 是为了实现将要遍历的List<?>指定到sheet和显示指定的列
				 * 如果 JXLListModel.sheet 不初始值则默认遍历到第一个sheet中
				 * 如果 JXLListModel.listShow 不初始值则默认显示list所有列
				 * 
				//String[] listCol = {"getId","getName","getAddress","getSchool","getClasses"} ;
				String[] listCol = {"getId","getName","getAddress","getSchool"} ;
				//替换指定的值
				Map<String,String> map = new HashMap<String,String>() ;
				map.put("test", "测试用的Test") ;
				map.put("list", "测试用的List") ;
				map.put("map", "测试用的Map") ;
				List<JXLListModel> tempList = new ArrayList<JXLListModel>() ;
					JXLListModel listModel = new JXLListModel() ;
					//listModel.setSheet(0) ;
					listModel.setList(list) ;
					listModel.setListX(0) ;
					listModel.setListY(1) ;
					listModel.setDisplayColumn(listCol) ;
					tempList.add(listModel) ;
					
				String[] listCol2 = {"getId","getName","getAddress","getSchool","getClasses"} ;
					listModel = new JXLListModel() ;
					listModel.setSheet(1) ;
					listModel.setList(list) ;
					listModel.setListX(0) ;
					listModel.setListY(2) ;
					listModel.setDisplayColumn(listCol2) ;
					tempList.add(listModel) ;
				
				List<JXLExcelModel> jxlModel = new ArrayList<JXLExcelModel>() ;
				JXLExcelModel model = new JXLExcelModel() ;
					model.setSheet(0) ;
					model.setStartX(0) ;
					model.setStartY(2) ;
					model.setEndX(1) ;
					model.setEndY(16) ;
					model.setMergeText("测试合并1") ;
					jxlModel.add(model) ;
					model = new JXLExcelModel() ;
					model.setSheet(1) ;
					model.setStartX(0) ;
					model.setStartY(2) ;
					model.setEndX(1) ;
					model.setEndY(16) ;
					model.setMergeText("测试合并2") ;
					jxlModel.add(model) ;
				
				int[][] mergeInt = {{2,1,100,0},{2,2,100,1}} ;
			com.ExcelImplTest.setExcelTest(filePath, map, tempList, jxlModel, mergeInt) ;
	 */
	/*
	 * String[][] insertImages  ： 插入图片  insertImage参数为   {{x,y,ImageUrl,width,height,Sheet},{x,y,ImageUrl,width,height,Sheet}}
	 * 													  X轴，Y轴，图片路径，宽度，高度，工作簿
	 * String[][] insertImages = {{"0","0","C://Image//image.jpg","100","100","0"}} ;全参数
	 * String[][] insertImages = {{"C://Image//image.jpg","100","100","0"}} ;
	 * String[][] insertImages = {{"0","0","C://Image//image.jpg""0"}} ;
	 * String[][] insertImages = {{"0","0","C://Image//image.jpg"}} ;
	 * String[][] insertImages = {{"C://Image//image.jpg","0"}} ;
	 * String[][] insertImages = {{"C://Image//image.jpg"}} ;
	 * */
	public static void setExcel(String filePath, Map<String,String> map, List<JXLListModel> listModel, List<JXLExcelModel> jxlList, int[][] mergeInt,String[][] insertImages, HttpServletResponse response) {
		try {
			jxlDocTemplateAll(filePath, map, listModel, jxlList, mergeInt,insertImages, response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}

	public static void setExcel(String filePath,String outPath, Map<String,String> map, List<JXLListModel> listModel, List<JXLExcelModel> jxlList, int[][] mergeInt, HttpServletResponse response) {
		try {
			jxlDocTemplateAll(filePath,outPath, map, listModel, jxlList, mergeInt, null, response) ;
		} catch (WriteException e) {
			e.printStackTrace();
		}
	}
	
	/* 
	 * <p>
	 * 		命名定义：
	 * 			workBookNumber  ：	工作表个数
	 * 			listModel		：	要处理的工作簿整合的List
	 * </p>
	 * */
	@SuppressWarnings("unchecked")
	public static void jxlDocTemplateAll(String filePath,Map<String,String> map, List<JXLListModel> listModel, List<JXLExcelModel> jxlList,int[][] mergeInt,String[][] insertImages, HttpServletResponse response) throws WriteException {
		//1：读取Excel模版文件，加载到WritableWorkbook中         开始 ----------------------------------------
		//1.1：设置输出模版的文件名，以_bak.xls结尾（待优化）
		String outPath = filePath.substring(0, filePath.length() - 4) + "_bak.xls" ;
		try {
			//1.2: 判断是否有单元格要进行合并   开始-----------------------------
			boolean merge = false ;
			if(jxlList != null) {
					/*	JXLModel这个Model中设置需要
						指定工作簿，如果是空的话默认为0
						合并单元格的起始X轴
						合并单元格的起始Y轴
						合并单元格的结束X轴
						合并单元格的结束Y轴
					*/
				merge = true ;
			}
			//1.2: 判断是否有单元格要进行合并   结束-----------------------------
			
			//1.3: 判断文件是否存在，如果存在才进行操作 
			if(fileExist(filePath)) {
				/* 1.4 开始============================================================================================
				 * 	<p>
				 * 		此操作作用于List<JXLListModel>中的参数有多个，说明了我们定义了一个EXCEL中有多个工作簿<sheet>需要操作。
				 * 		因此List<JXLListModel>.size() 为需要处理的工作表次数，我们用for循环来实现操作各个工作表内容。
				 *  </p>
				 */
				JXLListModel list = null ;  //定义JXL处理模型
				// 1.4.1 Workbook rwork 读取的模版只能读取不能修改
				rwork = Workbook.getWorkbook(new File(filePath)) ;  //读取模版文件
				// 1.4.2 WritableWorkbook wwb 通过创建WritableWorkbook，并加载rwork 来实现修改EXCEL的操作
				wwb = Workbook.createWorkbook(new FileOutputStream(outPath),rwork) ; //修改模版
				
				for(int sheetNumber = 0 ; sheetNumber < wwb.getSheets().length ; sheetNumber ++ ) {
					// 1.4.3 将指定的Map值替换到EXCEL所有的工作簿中 开始------------------------------------------------
					if(map != null) {
						/*
						 * <p>
						 * 		我们开始获取工作簿中需要替换的坐标。
						 * 		sheet每次读取时加载一次。
						 * 		获取坐标的格式设定为：
						 * 		Map<String,String>
						 * 		其中key为要替换的名称，value格式为坐标轴x|y
						 * </p>
						 * */
						//1.4.3 读取工作表
						sheetToMap = wwb.getSheet(sheetNumber) ;
						setIndexMap(filePath, map, sheetNumber) ;
						setMap(map) ;
					}
					// 1.4.3 将指定的Map值替换到EXCEL所有的工作簿中 结束------------------------------------------------
				}
				if(listModel != null) {
					for(int workBookNumber = 0 ; workBookNumber < listModel.size() ; workBookNumber ++ ) {
						list = listModel.get(workBookNumber) ;	//初始化第N个工作簿
						/*
						 * <p>
						 * 		将JXLListModel拆分，我们能得到以下参数：
						 * 		int sheet ;		需要操作的第几个工作簿
						 * 		List<?> list ;	需要遍历的List
						 * 		int listX ;		初始化此List的X轴坐标
						 * 		int listY ;		初始化此List的Y轴坐标
						 * </p>
						 */
						//1.4.3 读取工作表
						sheet = wwb.getSheet(list.getSheet()) ;
						//1.4.4 查找工作表，如果没有找到EXCEL中第N个工作簿，我们将自动在最后创建一个新的名为test的工作簿
						if(sheet == null) {
							sheet = wwb.createSheet("test", workBookNumber) ;
						}
						//1.4.5 遍历list到EXCEL指定工作簿中开始===========================================================
						if(list != null) {
							if(list.getList().size() > 0) {
								setList(list.getList(), list.getListX(), list.getListY(), list.getDisplayColumn()) ;
							}
						}
						//1.4.5 遍历list到EXCEL指定工作簿中结束===========================================================
						
					}
				}
				/*
				 * 1.4 结束============================================================================================
				 * */

					//1.7 对指定单元格进行合并  开始-----------------------------------------
					if(merge) {
						JXLExcelModel jxlModel = null ;
						WritableCellFormat wc3 = new WritableCellFormat() ;
						wc3.setAlignment(Alignment.CENTRE); // 设置居中
			            wc3.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
			          //  wc3.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
			            wc3.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
			            wc3.setWrap(true) ;  //设置单元格属性为自动换行
						for(int jj = 0 ; jj < jxlList.size() ; jj ++ ) {
							//sheet.mergeCells(0, 5, 0, (5 + getList().size()));
				            jxlModel = jxlList.get(jj) ;
				          //1.4.3 读取工作表
				            sheetToMerge = wwb.getSheet(jxlModel.getSheet()) ;
							//1.4.4 查找工作表，如果没有找到EXCEL中第N个工作簿，我们将自动在最后创建一个新的名为test的工作簿
							if(sheetToMerge == null) {
								sheetToMerge = wwb.createSheet("test", 0) ;
							}
							sheetToMerge.mergeCells(jxlModel.getStartX(), jxlModel.getStartY(), jxlModel.getEndX(), jxlModel.getEndY());
				             /* 如果有单元格进行合并，判断是否有需要填充的值
				             */
				            if(jxlModel.getMergeText() != null) {
				            	if(jxlModel.getFontFormat() != null) {
				            		WritableCellFormat wc4 = jxlModel.getFontFormat() ; //取得自定义的单元格属性
				            		sheetToMerge.addCell(new Label(jxlModel.getStartX(),jxlModel.getStartY(),jxlModel.getMergeText(),wc4)) ;
				            	} else {
				            		sheetToMerge.addCell(new Label(jxlModel.getStartX(),jxlModel.getStartY(),jxlModel.getMergeText(),wc3)) ;
				            	}
				            }
						}
					}
					//1.7 对指定样式进行合并  结束-----------------------------------------
					
					//1.8 插入图片 开始----------------------------------------------------
					if(insertImages != null) {
						if(insertImages.length > 0) {
							//1.8.1 循环插入图片 开始----------------------------------------------
							for(int insertImageInt = 0 ; insertImageInt < insertImages.length ; insertImageInt ++) {
								//读取图片、插入图片
								insertImage(insertImages[insertImageInt]) ;
							}
							//1.8.1 循环插入图片 结束----------------------------------------------
						}
					}
					//1.8 插入图片 结束----------------------------------------------------
					try {
		    			wwb.write() ;
		    		} catch(java.lang.ArrayIndexOutOfBoundsException e) {
		    			System.out.println("线程异常") ;
		    		}
				} else {
					System.out.println("模版文件不存在 !!!") ;
			}
		} catch(Exception e) {
			System.out.println(e) ;
		} finally {
			//9.关闭wwb,以释放内存
    		if(rwork != null) {
	    		rwork.close() ;
    		}
    		if(wwb != null) {
				try {
					wwb.close() ;
				} catch (WriteException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
    		}
    		/*for(int mergeSize = 0 ; mergeSize < mergeInt.length ; mergeSize ++) {
    			setMergeColumn(outPath, mergeInt, mergeSize) ;
    		}*/
			//8.通过流实现文件下载
    		if(response != null){
    			try {
        			//response = ServletActionContext.getResponse();
        			//String path = getRequest().getParameter("fileName");
        			// path是指欲下载的文件的路径。
        			File file = new File(outPath);
        			// 取得文件名。
        			String filename = file.getName();
        			// 以流的形式下载文件。
        			InputStream fis = new BufferedInputStream(new FileInputStream(outPath));
        			byte[] buffer = new byte[fis.available()];
        			fis.read(buffer);
        			fis.close();
        			// 清空response
        			response.reset();
        			// 设置response的Header
        			response.setHeader("Content-Type", "application/octet-stream");
        			response.addHeader("Content-Disposition", "attachment;filename=" + new String(filename.getBytes(), "ISO8859-1"));
        			response.addHeader("Content-Length", "" + file.length());
        			// response.setContentType("application/octet-stream");
        			OutputStream toClient = response.getOutputStream();
        			toClient.write(buffer);
        			toClient.flush();
        			toClient.close();
        		} catch (IOException ex) {
        			System.out.println(ex) ;
        		}
    		}
		}
	}
	/* 
	 * <p>
	 * 		命名定义：
	 * 			workBookNumber  ：	工作表个数
	 * 			listModel		：	要处理的工作簿整合的List
	 * </p>
	 * */
	@SuppressWarnings("unchecked")
	public static void jxlDocTemplateAll(String filePath,String outPath,Map<String,String> map, List<JXLListModel> listModel, List<JXLExcelModel> jxlList,int[][] mergeInt,String[][] insertImages, HttpServletResponse response) throws WriteException {
		//1：读取Excel模版文件，加载到WritableWorkbook中         开始 ----------------------------------------
		try {
			//1.2: 判断是否有单元格要进行合并   开始-----------------------------
			boolean merge = false ;
			if(jxlList != null) {
					/*	JXLModel这个Model中设置需要
						指定工作簿，如果是空的话默认为0
						合并单元格的起始X轴
						合并单元格的起始Y轴
						合并单元格的结束X轴
						合并单元格的结束Y轴
					*/
				merge = true ;
			}
			//1.2: 判断是否有单元格要进行合并   结束-----------------------------
			
			//1.3: 判断文件是否存在，如果存在才进行操作 
			if(fileExist(filePath)) {
				/* 1.4 开始============================================================================================
				 * 	<p>
				 * 		此操作作用于List<JXLListModel>中的参数有多个，说明了我们定义了一个EXCEL中有多个工作簿<sheet>需要操作。
				 * 		因此List<JXLListModel>.size() 为需要处理的工作表次数，我们用for循环来实现操作各个工作表内容。
				 *  </p>
				 */
				JXLListModel list = null ;  //定义JXL处理模型
				// 1.4.1 Workbook rwork 读取的模版只能读取不能修改
				rwork = Workbook.getWorkbook(new File(filePath)) ;  //读取模版文件
				// 1.4.2 WritableWorkbook wwb 通过创建WritableWorkbook，并加载rwork 来实现修改EXCEL的操作
				wwb = Workbook.createWorkbook(new FileOutputStream(outPath),rwork) ; //修改模版
				
				for(int sheetNumber = 0 ; sheetNumber < wwb.getSheets().length ; sheetNumber ++ ) {
					// 1.4.3 将指定的Map值替换到EXCEL所有的工作簿中 开始------------------------------------------------
					if(map != null) {
						/*
						 * <p>
						 * 		我们开始获取工作簿中需要替换的坐标。
						 * 		sheet每次读取时加载一次。
						 * 		获取坐标的格式设定为：
						 * 		Map<String,String>
						 * 		其中key为要替换的名称，value格式为坐标轴x|y
						 * </p>
						 * */
						//1.4.3 读取工作表
						sheetToMap = wwb.getSheet(sheetNumber) ;
						setIndexMap(filePath, map, sheetNumber) ;
						setMap(map) ;
					}
					// 1.4.3 将指定的Map值替换到EXCEL所有的工作簿中 结束------------------------------------------------
				}
				if(listModel != null) {
					for(int workBookNumber = 0 ; workBookNumber < listModel.size() ; workBookNumber ++ ) {
						list = listModel.get(workBookNumber) ;	//初始化第N个工作簿
						/*
						 * <p>
						 * 		将JXLListModel拆分，我们能得到以下参数：
						 * 		int sheet ;		需要操作的第几个工作簿
						 * 		List<?> list ;	需要遍历的List
						 * 		int listX ;		初始化此List的X轴坐标
						 * 		int listY ;		初始化此List的Y轴坐标
						 * </p>
						 */
						//1.4.3 读取工作表
						sheet = wwb.getSheet(list.getSheet()) ;
						//1.4.4 查找工作表，如果没有找到EXCEL中第N个工作簿，我们将自动在最后创建一个新的名为test的工作簿
						if(sheet == null) {
							sheet = wwb.createSheet("test", workBookNumber) ;
						}
						//1.4.5 遍历list到EXCEL指定工作簿中开始===========================================================
						if(list != null) {
							if(list.getList().size() > 0) {
								setList(list.getList(), list.getListX(), list.getListY(), list.getDisplayColumn()) ;
							}
						}
						//1.4.5 遍历list到EXCEL指定工作簿中结束===========================================================
						
					}
				}
				/*
				 * 1.4 结束============================================================================================
				 * */

					//1.7 对指定单元格进行合并  开始-----------------------------------------
					if(merge) {
						JXLExcelModel jxlModel = null ;
						WritableCellFormat wc3 = new WritableCellFormat() ;
						wc3.setAlignment(Alignment.CENTRE); // 设置居中
			            wc3.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
			          //  wc3.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
			            wc3.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
			            wc3.setWrap(true) ;  //设置单元格属性为自动换行
						for(int jj = 0 ; jj < jxlList.size() ; jj ++ ) {
							//sheet.mergeCells(0, 5, 0, (5 + getList().size()));
				            jxlModel = jxlList.get(jj) ;
				          //1.4.3 读取工作表
				            sheetToMerge = wwb.getSheet(jxlModel.getSheet()) ;
							//1.4.4 查找工作表，如果没有找到EXCEL中第N个工作簿，我们将自动在最后创建一个新的名为test的工作簿
							if(sheetToMerge == null) {
								sheetToMerge = wwb.createSheet("test", 0) ;
							}
							sheetToMerge.mergeCells(jxlModel.getStartX(), jxlModel.getStartY(), jxlModel.getEndX(), jxlModel.getEndY());
				             /* 如果有单元格进行合并，判断是否有需要填充的值
				             */
				            if(jxlModel.getMergeText() != null) {
				            	if(jxlModel.getFontFormat() != null) {
				            		WritableCellFormat wc4 = jxlModel.getFontFormat() ; //取得自定义的单元格属性
				            		sheetToMerge.addCell(new Label(jxlModel.getStartX(),jxlModel.getStartY(),jxlModel.getMergeText(),wc4)) ;
				            	} else {
				            		sheetToMerge.addCell(new Label(jxlModel.getStartX(),jxlModel.getStartY(),jxlModel.getMergeText(),wc3)) ;
				            	}
				            }
						}
					}
					//1.7 对指定样式进行合并  结束-----------------------------------------
					
					//1.8 插入图片 开始----------------------------------------------------
					if(insertImages != null) {
						if(insertImages.length > 0) {
							//1.8.1 循环插入图片 开始----------------------------------------------
							for(int insertImageInt = 0 ; insertImageInt < insertImages.length ; insertImageInt ++) {
								//读取图片、插入图片
								insertImage(insertImages[insertImageInt]) ;
							}
							//1.8.1 循环插入图片 结束----------------------------------------------
						}
					}
					//1.8 插入图片 结束----------------------------------------------------
					try {
		    			wwb.write() ;
		    		} catch(java.lang.ArrayIndexOutOfBoundsException e) {
		    			System.out.println("线程异常") ;
		    		}
				} else {
					System.out.println("模版文件不存在 !!!") ;
			}
		} catch(Exception e) {
			System.out.println(e) ;
		} finally {
			//9.关闭wwb,以释放内存
    		if(rwork != null) {
	    		rwork.close() ;
    		}
    		if(wwb != null) {
				try {
					wwb.close() ;
				} catch (WriteException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
    		}
    		/*for(int mergeSize = 0 ; mergeSize < mergeInt.length ; mergeSize ++) {
    			setMergeColumn(outPath, mergeInt, mergeSize) ;
    		}*/
			//8.通过流实现文件下载
    		if(response != null){
    			try {
        			//response = ServletActionContext.getResponse();
        			//String path = getRequest().getParameter("fileName");
        			// path是指欲下载的文件的路径。
        			File file = new File(outPath);
        			// 取得文件名。
        			String filename = file.getName();
        			// 以流的形式下载文件。
        			InputStream fis = new BufferedInputStream(new FileInputStream(outPath));
        			byte[] buffer = new byte[fis.available()];
        			fis.read(buffer);
        			fis.close();
        			// 清空response
        			response.reset();
        			// 设置response的Header
        			response.setHeader("Content-Type", "application/octet-stream");
        			response.addHeader("Content-Disposition", "attachment;filename=" + new String(filename.getBytes(), "ISO8859-1"));
        			response.addHeader("Content-Length", "" + file.length());
        			// response.setContentType("application/octet-stream");
        			OutputStream toClient = response.getOutputStream();
        			toClient.write(buffer);
        			toClient.flush();
        			toClient.close();
        		} catch (IOException ex) {
        			System.out.println(ex) ;
        		}
    		}
		}
	}
	private static boolean isIntager(String str) {
		try {
			Integer.parseInt(str) ;
			return true ;
		} catch(java.lang.NumberFormatException e) {
			return false ;
		}
	}
	//插入图片
	private static void insertImage(String[] imageAttribute) {
		try {
			@SuppressWarnings("unused")
			boolean imagUrl = false ; //是否有图片路径
				@SuppressWarnings("unused")
				String filePath = "" ;
			boolean imgSheet = false ; //是否指定工作簿
				int imgSheetInt = 0 ;
			boolean imgXY = false ; //是否制定坐标
				int imgX = 0 ,imgY = 0 ;
			boolean imgWH = false ; //是否指定宽、高
				int imgWidth = 0 ,imgHeight = 0 ;
			int ii = imageAttribute.length ;
			if(ii == 1) {
				imagUrl = true ;
				filePath = imageAttribute[0] ;
			} else if(ii == 2) {
				imagUrl = true ;
				filePath = imageAttribute[0] ;
				imgSheet = true ;
				imgSheetInt = Integer.parseInt(imageAttribute[1]) ;
			} else if(ii == 3){
				if(isIntager(imageAttribute[0])) { // X Y URL
					imgXY = true ;
					imagUrl = true ;
					imgX = Integer.parseInt(imageAttribute[0]) ;
					imgY = Integer.parseInt(imageAttribute[1]) ;
					filePath = imageAttribute[2] ;
				} else {
					imgWH = true ;
					imagUrl = true ;
					filePath = imageAttribute[0] ;
					imgWidth = Integer.parseInt(imageAttribute[1]) ;
					imgHeight = Integer.parseInt(imageAttribute[2]) ;
				}
			} else if(ii == 4) {
				if(isIntager(imageAttribute[0])) { // X Y URL
					imgXY = true ;
					imagUrl = true ;
					imgSheet = true ;
					imgX = Integer.parseInt(imageAttribute[0]) ;
					imgY = Integer.parseInt(imageAttribute[1]) ;
					filePath = imageAttribute[2] ;
					imgSheetInt = Integer.parseInt(imageAttribute[3]) ;
				} else {
					imgWH = true ;
					imagUrl = true ;
					imgSheet = true ;
					filePath = imageAttribute[0] ;
					imgWidth = Integer.parseInt(imageAttribute[1]) ;
					imgHeight = Integer.parseInt(imageAttribute[2]) ;
					imgSheetInt = Integer.parseInt(imageAttribute[3]) ;
				}
			} else {
				imgXY = true ;
				imagUrl = true ;
				imgWH = true ;
				imgSheet = true ;
				imgX = Integer.parseInt(imageAttribute[0]) ;
				imgY = Integer.parseInt(imageAttribute[1]) ;
				filePath = imageAttribute[2] ;
				imgWidth = Integer.parseInt(imageAttribute[3]) ;
				imgHeight = Integer.parseInt(imageAttribute[4]) ;
				imgSheetInt = Integer.parseInt(imageAttribute[5]) ;
			}
			sheet = wwb.getSheet((imgSheet == true?imgSheetInt:0)) ;
				if(fileExist(imageAttribute[0])) {
					File image = new File(imageAttribute[0]) ; //得到文件
					java.awt.image.BufferedImage bi7 = null ; //创建Image容器
			        try
			        {
			            bi7 = javax.imageio.ImageIO.read(image) ; //通过路径得到图片
			        }
			        catch (IOException e)
			        {
			            e.printStackTrace();
			        }
			        if(bi7 != null) { //得到图片
			        	int picWidth = imgWH == true?imgWidth: bi7.getWidth() ; // 图片宽
				        int picHeight =imgWH == true?imgHeight: bi7.getHeight() ; // 图片高
				        // 输入参数, 图片显示的位置
				        double picBeginCol = 1.2;
				        double picBeginRow = 1.2;
				        double picCellWidth = 0.0; // 是 cell的跨越个数, 可小数
				        double picCellHeight = 0.0;
				        int _picWidth = picWidth * 32 ; // pic的宽度,循环递减, 是jxl的宽度单位, 32/15
				        for(int x=0; x< 1234; x++)
				        {
				            int bc = (int)Math.floor( picBeginCol + x ); // 3.6 to 3 // 本次循环所在cell位置
				            int v = sheet.getColumnView( bc ).getSize(); //本次cell宽,jxl单位
				            double _offset0 = 0.0; // >= 0 // 离左边的偏移量, 仅 x = 0 的时候才用
				            if( 0 == x )
				                _offset0 = ( picBeginCol - bc ) * v ; //
				            if( 0.0 + _offset0 + _picWidth > v ) // _picWidth 剩余长度超过一个cell时
				            {
				                // 计算本次cell内, pic 所占 ratio值, 累加到 picCellWidth
				                double _ratio = 1.0;
				                if( 0 == x )
				                    _ratio = ( 0.0 + v - _offset0 ) / v;
				                picCellWidth += _ratio;
				                _picWidth -= (int)( 0.0 + v - _offset0 ); // int
				            } else {// _picWidth 剩余长度在一个cell内时
				                double _ratio = 0.0;
				                if( v != 0 )
				                    _ratio = ( 0.0 + _picWidth ) / v;
				                picCellWidth += _ratio;
				                break;
				            }
				            if( x >= 1233 )
				                {}
				        }
				        int _picHeight = picHeight * 15 ; // pic的高度,循环递减, 是jxl的高度单位, 32/15
				        for(int x=0; x< 1234; x++)
				        {
				            int bc = (int)Math.floor( picBeginRow + x ); // 3.6 to 3 // 本次循环所在cell位置
				            int v = sheet.getRowView( bc ).getSize(); //本次cell高,jxl单位
				            double _offset0 = 0.0; // >= 0 // 离顶部的偏移量, 仅 x = 0 的时候才用
				            if( 0 == x )
				                _offset0 = ( picBeginRow - bc ) * v ; //
				            if( 0.0 + _offset0 + _picHeight > v ) // _picHeight 剩余长度超过一个cell时
				            {
				                // 计算本次cell内, pic 所占 ratio值, 累加到 picCellHeight
				                double _ratio = 1.0;
				                if( 0 == x )
				                    _ratio = ( 0.0 + v - _offset0 ) / v;
				                // picCellHeight += 1.0;
				                picCellHeight += _ratio;
				                _picHeight -= (int)( 0.0 + v - _offset0 ); // int
				            } else { // _picHeight 剩余长度在一个cell内时
				                double _ratio = 0.0;
				                if( v != 0 )
				                    _ratio = ( 0.0 + _picHeight ) / v;
				                picCellHeight += _ratio;
				                break;
				            } 
				            if( x >= 1233 )
			                {}
				        } 
				        WritableImage wimage = new WritableImage((imgXY == true?imgX:0), (imgXY == true?imgY:0), picCellWidth, picCellHeight, image);
				        sheet.addImage(wimage);
				        wwb.write() ;
			        }
				}
			//sheet = wwb.getSheet(list.getSheet()) ;
		} catch(Exception e) {
			e.printStackTrace() ;
		}
	}
	@SuppressWarnings("unused")
	private static void setMergeColumn(final String outPath, final int[][] mergeInt, final int mergeSize) throws WriteException {
		HSSFWorkbook rwb2 = null ;
		//8.对指定列进行上下行合并   开始----------------------------------------------------------
		if(mergeInt != null) {
			try {
				rwb2 = new HSSFWorkbook(new FileInputStream(outPath));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			HSSFSheet sht2 = rwb2.getSheetAt(mergeSize) ;
			HSSFRow rows = null ;
			HSSFCell cl = null ;
			HSSFRow rows2 = null ;
			HSSFCell cl2 = null ;
			Workbook rwork2 = null ;
			WritableWorkbook wwb2 = null ;
			try {
				rwork2 = Workbook.getWorkbook(new File(outPath)) ;
			} catch (BiffException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}  //读取模版文件
			try {
				wwb2 = Workbook.createWorkbook(new FileOutputStream(outPath),rwork2) ;
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			} //修改模版
			WritableSheet sheet2 = null ;
			WritableCellFormat wc4 = new WritableCellFormat();
			wc4.setAlignment(Alignment.CENTRE);
			wc4.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
	        wc4.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
	        wc4.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
	        wc4.setWrap(true) ;  //设置单元格属性为自动换行
	        sheet2 = wwb2.getSheet(mergeSize) ;
			for(int mergeM = 0 ; mergeM < mergeInt.length ; mergeM ++ ) {
				int maxMergeInt = 0 ;
				for(int mergeMin = mergeInt[mergeM][1] ; mergeMin < (mergeInt[mergeM][1] + mergeInt[mergeM][2]) - 1 ;) {
					//这里是指定行
					rows = sht2.getRow(mergeMin) ;  //rows得到当前行的数据
					if(rows == null) {
						continue ;
					} else {
						cl = rows.getCell(mergeInt[mergeM][0]) ;
						maxMergeInt = 1 ;
						//从本行起开始遍历行，一直到和本行值不一样为止
						for(int maxMergeIntSize = mergeMin ; maxMergeIntSize < (mergeInt[mergeM][1] + mergeInt[mergeM][2]) - 1 ; maxMergeIntSize ++ ) {
							//循环到下N行，如果本行的值是相同的;
							rows2 = sht2.getRow(mergeMin + maxMergeInt) ;
							//System.out.println((short)mergeInt[mergeM][0] + " | " + mergeM + " | " + mergeMin + " | " + maxMergeInt) ;
							try {
								cl2 = rows2.getCell(mergeInt[mergeM][0]) ;
							} catch(java.lang.NullPointerException e) {
								//cl2 = rows2.getCell((short)(mergeInt[mergeM][0])) ;
								break ;
							}
							if(cl != null && cl2 != null) {
								if(!cl.getRichStringCellValue().toString().equals("") && cl.getRichStringCellValue().toString().trim().equals(cl2.getRichStringCellValue().toString().trim())) {
									maxMergeInt ++ ;
								} else {
									break ;
								}
							}
						}
						rows2 = sht2.getRow(mergeMin + maxMergeInt - 1) ;
						cl2 = rows2.getCell(mergeInt[mergeM][0]) ;
						if(cl != null && cl2 != null) {
							if(!cl.getRichStringCellValue().toString().equals("") && cl.getRichStringCellValue().toString().trim().equals(cl2.getRichStringCellValue().toString().trim())) {
								//如果列的上下行相等，得到X，Y坐标，并进行合并
					            try {
							            sheet2.mergeCells(mergeInt[mergeM][0], mergeMin, mergeInt[mergeM][0], mergeMin + maxMergeInt - 1) ;
							            sheet2.addCell(new Label(mergeInt[mergeM][0], mergeMin ,cl2.getRichStringCellValue().toString(),wc4)) ;
								} catch (WriteException e) {
									e.printStackTrace();
								} // 设置居中
							} else {
							}
						}
					}
					 mergeMin += maxMergeInt ;
				}
			}
			try {
				wwb2.write() ;
				rwork2.close() ;
				try {
					wwb2.close() ;
				} catch (WriteException e) {
					e.printStackTrace();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	//设置indexMap坐标（用于指定sheet中的map）
	@SuppressWarnings("unused")
	private static void setIndexMap(final String filePath, final Map<String,String> map, final int sheetNum) {
		try {
			HSSFWorkbook rwb = new HSSFWorkbook(new FileInputStream(filePath)) ;
			//1.3.2 得到模版中的工作表（待优化），本文只能对模版中的第一个工作表进行修改，应该设置为可配置项
			HSSFSheet sht = rwb.getSheetAt(sheetNum) ;
			if(sht == null) {
				sht = rwb.getSheetAt(0) ;
			}
			indexMap = new HashMap<String,String>() ;
			String indexList = "" ;
			for(String value:map.keySet()) {//遍历是否存在要替换的Parameter坐标，并记录在Map中  格式：  x|y  
				try {
					//1.3.5 通过方法getCellindex(工作表,要比较的值) 得到在excel中详细坐标的核心方法
					indexList = getCellindex(sht, value) ;
				} catch(java.lang.RuntimeException e) {
					continue ;
				}
				//1.3.6 向indexMap插入得到的值
				indexMap.put(value, indexList) ;
			}
		} catch(Exception e) {
			System.out.println("  ==  设置坐标失败  ==  ") ;
		}
	}
	
	//遍历Map到excel中
	@SuppressWarnings("unused")
	private static void setMap(final Map<String,String> map) {
		try {
			WritableCellFormat wc1 = new WritableCellFormat();
			wc1.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
			//wc1.setBackground(jxl.format.Colour.BLACK); // 设置单元格的背景颜色
            wc1.setAlignment(Alignment.CENTRE); // 设置居中
            wc1.setBorder(Border.ALL, BorderLineStyle.NONE); // 设置边框线
            wc1.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
            wc1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
			for(String value:indexMap.keySet()) {
				//得到x轴坐标
				
				int x = Integer.parseInt(indexMap.get(value).split("#")[0]) ;
				//得到y轴坐标
				int y = Integer.parseInt(indexMap.get(value).split("#")[1]) ;
	            //wc.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
	            //wc.setBackground(jxl.format.Colour.BLACK); // 设置单元格的背景颜色
	            //WritableFont wfont = new WritableFont(WritableFont.createFont("宋体"), 14);
	            //WritableCellFormat font = new WritableCellFormat(wfont);
	            Label label01 = null ;
	            label01 = new Label(y,x,map.get(value),wc1) ;
	            //author wdx 20130326
	            if(x==0){ //判断是否是第一行，第一行为大标题，可能对其他的表格式有影响
		            WritableFont wfont = new WritableFont(WritableFont.createFont("宋体"), 20);
		            WritableCellFormat font = new WritableCellFormat(wfont);
		            if(value.equals("head")){
		            	font.setBackground(jxl.format.Colour.GRAY_25);
		            	font.setBorder(Border.BOTTOM, BorderLineStyle.THIN);
		            	font.setFont(new WritableFont(WritableFont.createFont("Arial"), 20,WritableFont.BOLD)) ;
		            }
		            font.setAlignment(Alignment.CENTRE);
	            	label01.setCellFormat(font);
	            	
	            }else{
	            	WritableCellFormat wc2 = new WritableCellFormat();
	            	 //修改打印表单作为参数能添加边框
	            	     wc2.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
	         			//wc1.setBackground(jxl.format.Colour.BLACK); // 设置单元格的背景颜色
	            		 wc2.setAlignment(Alignment.CENTRE); // 设置居中
	            		 wc2.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
	            		 wc2.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
	            	    if(map.get(value).equals("签证送办日期")||map.get(value).equals("签证返回日期")||map.get(value).equals("签证受理日期")){
	            		 wc2.setBorder(Border.TOP, BorderLineStyle.THIN);
	            	    }
	            	    if(value.equals("total")){
	            	    	wc2.setVerticalAlignment(jxl.format.VerticalAlignment.TOP);//上下居中
	            	    	wc2.setFont(new WritableFont(WritableFont.createFont("Arial"), 20,WritableFont.BOLD)) ;
	            	    }
	            	 label01.setCellFormat(wc2);
	            }
	            sheetToMap.addCell(label01) ;
			}
		} catch(Exception e) {
			System.out.println("  ==  遍历sheet Map 失败  ==  ") ;
		}
	}
	
	//遍历List<?>到excel中
	@SuppressWarnings("unchecked")
	private static void setList(List<?> list, int listX, int listY, String[] displayColumm) {
		try {
			//1.6.1 通过反射得到list的所有列和值，并返回一个二维数组的list， list[0]返回类型  list[1]返回get方法  list[2]返回值
			List<Object> listValue = ReflectUtil.getAllFieldAndValue2(list,displayColumm) ;
			//1.6.2 只要返回值的list
    		List<Object[]> dataValueList = (List<Object[]>) listValue.get(2) ;
    		WritableCellFormat wc2 = new WritableCellFormat();
            wc2.setAlignment(Alignment.CENTRE); // 设置居中
            wc2.setFont(new WritableFont(WritableFont.createFont("宋体"), 12)) ;
            wc2.setBorder(Border.ALL, BorderLineStyle.THIN); // 设置边框线
            wc2.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);//上下居中
            wc2.setWrap(true) ;  //设置单元格属性为自动换行
			for(int i = 0 ; i < dataValueList.size() ; i ++ ) {
	           sheet.insertRow(listY) ; //在指定位置插入一新行，用以插入数据
	            Label label02 = null ;
	            Object[] object = dataValueList.get(i) ;
	    		for(int num = 0 ; num < object.length ; num ++ ) {
	    			String value = "" ;
	    			if(object[num] != null ) {
	    				value = object[num].toString() ;
	    			}
	    			label02 =  new Label(listX + num , listY, value ,wc2) ;
	    			sheet.addCell(label02) ;
	    		}
				listY += 1 ;
			}
		} catch(Exception e) {
			System.out.println("  ==  遍历List<?> 出错   ==  ") ;
		}
	}
	
	/*
	 * 通过Field遍历Object Bean的值
	 * */
	 public static Object[] field2Value(Field[] f, Object o) throws Exception {
		 Object[] value = new Object[f.length];
		 for (int i = 0; i < f.length; i++) {
			 //try {
				 value[i] = f[i].get(o);
				 //System.out.println(value[i]);
			// } catch(Exception e) {
			//	 value[i] = "" ;
			// }
		 }
		 return value;
	}

	/**
	 * 判断XML文件是否存在.
	 * @param fileName
	 * @return
	 */
	private static boolean fileExist(String realPath) {
		java.io.File objFile = new java.io.File(realPath) ; 
		if (objFile.exists()) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * 查找匹配的单元格
	 * @param sheet 
	 * @param value 根据此参数查找单元格的值
	 * @param 必须在EXCEL表中存在要替换的Paremeter值
	 * @return Cell
	 */
	public static String getCellindex(HSSFSheet sheet,String value) {
		String list = "" ;
		HSSFCell cell = null;
		HSSFRow rows = null ;
		HSSFCell cl = null ;
		for (int i = sheet.getFirstRowNum(); i <= sheet.getLastRowNum(); i++) {
			//Row row = sheet.getRow(i);
			rows = sheet.getRow(i) ;
			if (rows == null) {
				continue;
			} else {
				for (int j = rows.getFirstCellNum(); j < rows.getLastCellNum(); j++) {
					cl = rows.getCell(j) ;
					if (cl == null) {
						continue;
					} else {
						if (String.valueOf(cl.getRichStringCellValue()).equals(value.trim())) {
							cell = cl;
							list = i + "#" + j ;
							break ;
						} else {
							continue;
						}
					}
				}
			}
		}
		if (cell == null) {
			throw new RuntimeException("没有比配的单元格");
		}
		return list ;
	}
}