在編寫ExcelUtil之前，在網上查了一些資料。java中用來處理Excel的第三方開源專案主要就是POI和JXL。poi功能強大，但是比較耗資源，對於大資料量的匯入匯出效能不是太好；jxl功能簡單，但是效能比較好。

由於本專案的匯入匯出更多關注效能問題，而且jxl提供的功能基本也都夠用了，於是選擇了jxl作為支援。

實戰

匯出就是將List轉化為Excel（listToExcel）

匯入就是將Excel轉化為List（excelToList）

匯入匯出中會出現各種各樣的問題，比如：資料來源為空、有重複行等，我自定義了一個ExcelException異常類，用來處理這些問題。

ExcelException

類

    package common.tool.excel;  
      
    public class ExcelException extends Exception {  
      
        public ExcelException() {  
            // TODO Auto-generated constructor stub  
        }  
      
        public ExcelException(String message) {  
            super(message);  
            // TODO Auto-generated constructor stub  
        }  
      
        public ExcelException(Throwable cause) {  
            super(cause);  
            // TODO Auto-generated constructor stub  
        }  
      
        public ExcelException(String message, Throwable cause) {  
            super(message, cause);  
            // TODO Auto-generated constructor stub  
        }  
      
      
    }  
 

ExcelUitl類

    /** 
     * @author     : WH 
     * @group      : tgb8 
     * @Date       : 2014-1-2 下午9:13:21 
     * @Comments   : 匯入匯出Excel工具類 
     * @Version    : 1.0.0 
     */  
      
    public class ExcelUtil  {  
          
        /** 
         * @MethodName  : listToExcel 
         * @Description : 匯出Excel（可以匯出到本地檔案系統，也可以匯出到瀏覽器，可自定義工作表大小） 
         * @param list      資料來源 
         * @param fieldMap      類的英文屬性和Excel中的中文列名的對應關係 
         * 如果需要的是引用物件的屬性，則英文屬性使用類似於EL表示式的格式 
         * 如：list中存放的都是student，student中又有college屬性，而我們需要學院名稱，則可以這樣寫 
         * fieldMap.put("college.collegeName","學院名稱") 
         * @param sheetName 工作表的名稱 
         * @param sheetSize 每個工作表中記錄的最大個數 
         * @param out       匯出流 
         * @throws ExcelException 
         */  
        public static <T>  void   listToExcel (  
                List<T> list ,  
                LinkedHashMap<String,String> fieldMap,  
                String sheetName,  
                int sheetSize,  
                OutputStream out  
                ) throws ExcelException{  
              
              
            if(list.size()==0 || list==null){  
                throw new ExcelException("資料來源中沒有任何資料");  
            }  
              
            if(sheetSize>65535 || sheetSize<1){  
                sheetSize=65535;  
            }  
              
            //建立工作簿併發送到OutputStream指定的地方  
            WritableWorkbook wwb;  
            try {  
                wwb = Workbook.createWorkbook(out);  
                  
                //因為2003的Excel一個工作表最多可以有65536條記錄，除去列頭剩下65535條  
                //所以如果記錄太多，需要放到多個工作表中，其實就是個分頁的過程  
                //1.計算一共有多少個工作表  
                double sheetNum=Math.ceil(list.size()/new Integer(sheetSize).doubleValue());  
                  
                //2.建立相應的工作表，並向其中填充資料  
                for(int i=0; i<sheetNum; i++){  
                    //如果只有一個工作表的情況  
                    if(1==sheetNum){  
                        WritableSheet sheet=wwb.createSheet(sheetName, i);  
                        fillSheet(sheet, list, fieldMap, 0, list.size()-1);  
                      
                    //有多個工作表的情況  
                    }else{  
                        WritableSheet sheet=wwb.createSheet(sheetName+(i+1), i);  
                          
                        //獲取開始索引和結束索引  
                        int firstIndex=i*sheetSize;  
                        int lastIndex=(i+1)*sheetSize-1>list.size()-1 ? list.size()-1 : (i+1)*sheetSize-1;  
                        //填充工作表  
                        fillSheet(sheet, list, fieldMap, firstIndex, lastIndex);  
                    }  
                }  
                  
                wwb.write();  
                wwb.close();  
              
            }catch (Exception e) {  
                e.printStackTrace();  
                //如果是ExcelException，則直接丟擲  
                if(e instanceof ExcelException){  
                    throw (ExcelException)e;  
                  
                //否則將其它異常包裝成ExcelException再丟擲  
                }else{  
                    throw new ExcelException("匯出Excel失敗");  
                }  
            }  
                  
        }  
          
        /** 
         * @MethodName  : listToExcel 
         * @Description : 匯出Excel（可以匯出到本地檔案系統，也可以匯出到瀏覽器，工作表大小為2003支援的最大值） 
         * @param list      資料來源 
         * @param fieldMap      類的英文屬性和Excel中的中文列名的對應關係 
         * @param out       匯出流 
         * @throws ExcelException 
         */  
        public static  <T>  void   listToExcel (  
                List<T> list ,  
                LinkedHashMap<String,String> fieldMap,  
                String sheetName,  
                OutputStream out  
                ) throws ExcelException{  
              
            listToExcel(list, fieldMap, sheetName, 65535, out);  
              
        }  
          
          
        /** 
         * @MethodName  : listToExcel 
         * @Description : 匯出Excel（匯出到瀏覽器，可以自定義工作表的大小） 
         * @param list      資料來源 
         * @param fieldMap      類的英文屬性和Excel中的中文列名的對應關係 
         * @param sheetSize    每個工作表中記錄的最大個數 
         * @param response  使用response可以匯出到瀏覽器 
         * @throws ExcelException 
         */  
        public static  <T>  void   listToExcel (  
                List<T> list ,  
                LinkedHashMap<String,String> fieldMap,  
                String sheetName,  
                int sheetSize,  
                HttpServletResponse response   
                ) throws ExcelException{  
              
            //設定預設檔名為當前時間：年月日時分秒  
            String fileName=new SimpleDateFormat("yyyyMMddhhmmss").format(new Date()).toString();  
              
            //設定response頭資訊  
            response.reset();            
            response.setContentType("application/vnd.ms-excel");        //改成輸出excel檔案  
            response.setHeader("Content-disposition","attachment; filename="+fileName+".xls" );  
      
            //建立工作簿併發送到瀏覽器  
            try {  
                  
                OutputStream out=response.getOutputStream();  
                listToExcel(list, fieldMap, sheetName, sheetSize,out );  
                  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                //如果是ExcelException，則直接丟擲  
                if(e instanceof ExcelException){  
                    throw (ExcelException)e;  
                  
                //否則將其它異常包裝成ExcelException再丟擲  
                }else{  
                    throw new ExcelException("匯出Excel失敗");  
                }  
            }  
        }  
          
          
        /** 
         * @MethodName  : listToExcel 
         * @Description : 匯出Excel（匯出到瀏覽器，工作表的大小是2003支援的最大值） 
         * @param list      資料來源 
         * @param fieldMap      類的英文屬性和Excel中的中文列名的對應關係 
         * @param response  使用response可以匯出到瀏覽器 
         * @throws ExcelException 
         */  
        public static <T>  void   listToExcel (  
                List<T> list ,  
                LinkedHashMap<String,String> fieldMap,  
                String sheetName,  
                HttpServletResponse response   
                ) throws ExcelException{  
              
            listToExcel(list, fieldMap, sheetName, 65535, response);  
        }  
          
        /** 
         * @MethodName          : excelToList 
         * @Description             : 將Excel轉化為List 
         * @param in                    ：承載著Excel的輸入流 
         * @param sheetIndex        ：要匯入的工作表序號 
         * @param entityClass       ：List中物件的型別（Excel中的每一行都要轉化為該型別的物件） 
         * @param fieldMap          ：Excel中的中文列頭和類的英文屬性的對應關係Map 
         * @param uniqueFields  ：指定業務主鍵組合（即複合主鍵），這些列的組合不能重複 
         * @return                      ：List 
         * @throws ExcelException 
         */  
        public static <T>  List<T>  excelToList(  
                InputStream in,  
                String sheetName,  
                Class<T> entityClass,  
                LinkedHashMap<String, String> fieldMap,  
                String[] uniqueFields  
                ) throws ExcelException{  
              
            //定義要返回的list  
            List<T> resultList=new ArrayList<T>();  
              
            try {  
                  
                //根據Excel資料來源建立WorkBook  
                Workbook wb=Workbook.getWorkbook(in);  
                //獲取工作表  
                Sheet sheet=wb.getSheet(sheetName);  
                  
                //獲取工作表的有效行數  
                int realRows=0;  
                for(int i=0;i<sheet.getRows();i++){  
                      
                    int nullCols=0;  
                    for(int j=0;j<sheet.getColumns();j++){  
                        Cell currentCell=sheet.getCell(j,i);  
                        if(currentCell==null || "".equals(currentCell.getContents().toString())){  
                            nullCols++;  
                        }  
                    }  
                      
                    if(nullCols==sheet.getColumns()){  
                        break;  
                    }else{  
                        realRows++;  
                    }  
                }  
                  
                  
                //如果Excel中沒有資料則提示錯誤  
                if(realRows<=1){  
                    throw new ExcelException("Excel檔案中沒有任何資料");  
                }  
                  
                  
                Cell[] firstRow=sheet.getRow(0);  
      
                String[] excelFieldNames=new String[firstRow.length];  
                  
                //獲取Excel中的列名  
                for(int i=0;i<firstRow.length;i++){  
                    excelFieldNames[i]=firstRow[i].getContents().toString().trim();  
                }  
                  
                //判斷需要的欄位在Excel中是否都存在  
                boolean isExist=true;  
                List<String> excelFieldList=Arrays.asList(excelFieldNames);  
                for(String cnName : fieldMap.keySet()){  
                    if(!excelFieldList.contains(cnName)){  
                        isExist=false;  
                        break;  
                    }  
                }  
                  
                //如果有列名不存在，則丟擲異常，提示錯誤  
                if(!isExist){  
                    throw new ExcelException("Excel中缺少必要的欄位，或欄位名稱有誤");  
                }  
                  
                  
                //將列名和列號放入Map中,這樣通過列名就可以拿到列號  
                LinkedHashMap<String, Integer> colMap=new LinkedHashMap<String, Integer>();  
                for(int i=0;i<excelFieldNames.length;i++){  
                    colMap.put(excelFieldNames[i], firstRow[i].getColumn());  
                }   
                  
                  
                  
                //判斷是否有重複行  
                //1.獲取uniqueFields指定的列  
                Cell[][] uniqueCells=new Cell[uniqueFields.length][];  
                for(int i=0;i<uniqueFields.length;i++){  
                    int col=colMap.get(uniqueFields[i]);  
                    uniqueCells[i]=sheet.getColumn(col);  
                }  
                  
                //2.從指定列中尋找重複行  
                for(int i=1;i<realRows;i++){  
                    int nullCols=0;  
                    for(int j=0;j<uniqueFields.length;j++){  
                        String currentContent=uniqueCells[j][i].getContents();  
                        Cell sameCell=sheet.findCell(currentContent,   
                                uniqueCells[j][i].getColumn(),  
                                uniqueCells[j][i].getRow()+1,   
                                uniqueCells[j][i].getColumn(),   
                                uniqueCells[j][realRows-1].getRow(),   
                                true);  
                        if(sameCell!=null){  
                            nullCols++;  
                        }  
                    }  
                      
                    if(nullCols==uniqueFields.length){  
                        throw new ExcelException("Excel中有重複行，請檢查");  
                    }  
                }  
      
                //將sheet轉換為list  
                for(int i=1;i<realRows;i++){  
                    //新建要轉換的物件  
                    T entity=entityClass.newInstance();  
                      
                    //給物件中的欄位賦值  
                    for(Entry<String, String> entry : fieldMap.entrySet()){  
                        //獲取中文欄位名  
                        String cnNormalName=entry.getKey();  
                        //獲取英文欄位名  
                        String enNormalName=entry.getValue();  
                        //根據中文欄位名獲取列號  
                        int col=colMap.get(cnNormalName);  
                          
                        //獲取當前單元格中的內容  
                        String content=sheet.getCell(col, i).getContents().toString().trim();  
                          
                        //給物件賦值  
                        setFieldValueByName(enNormalName, content, entity);  
                    }  
                      
                    resultList.add(entity);  
                }  
            } catch(Exception e){  
                e.printStackTrace();  
                //如果是ExcelException，則直接丟擲  
                if(e instanceof ExcelException){  
                    throw (ExcelException)e;  
                  
                //否則將其它異常包裝成ExcelException再丟擲  
                }else{  
                    e.printStackTrace();  
                    throw new ExcelException("匯入Excel失敗");  
                }  
            }  
            return resultList;  
        }  
          
          
          
          
          
        /*<-------------------------輔助的私有方法----------------------------------------------->*/  
        /** 
         * @MethodName  : getFieldValueByName 
         * @Description : 根據欄位名獲取欄位值 
         * @param fieldName 欄位名 
         * @param o 物件 
         * @return  欄位值 
         */  
        private static  Object getFieldValueByName(String fieldName, Object o) throws Exception{  
              
            Object value=null;  
            Field field=getFieldByName(fieldName, o.getClass());  
              
            if(field !=null){  
                field.setAccessible(true);  
                value=field.get(o);  
            }else{  
                throw new ExcelException(o.getClass().getSimpleName() + "類不存在欄位名 "+fieldName);  
            }  
              
            return value;  
        }  
          
        /** 
         * @MethodName  : getFieldByName 
         * @Description : 根據欄位名獲取欄位 
         * @param fieldName 欄位名 
         * @param clazz 包含該欄位的類 
         * @return 欄位 
         */  
        private static Field getFieldByName(String fieldName, Class<?>  clazz){  
            //拿到本類的所有欄位  
            Field[] selfFields=clazz.getDeclaredFields();  
              
            //如果本類中存在該欄位，則返回  
            for(Field field : selfFields){  
                if(field.getName().equals(fieldName)){  
                    return field;  
                }  
            }  
              
            //否則，檢視父類中是否存在此欄位，如果有則返回  
            Class<?> superClazz=clazz.getSuperclass();  
            if(superClazz!=null  &&  superClazz !=Object.class){  
                return getFieldByName(fieldName, superClazz);  
            }  
              
            //如果本類和父類都沒有，則返回空  
            return null;  
        }  
          
          
          
        /** 
         * @MethodName  : getFieldValueByNameSequence 
         * @Description :  
         * 根據帶路徑或不帶路徑的屬性名獲取屬性值 
         * 即接受簡單屬性名，如userName等，又接受帶路徑的屬性名，如student.department.name等 
         *  
         * @param fieldNameSequence  帶路徑的屬性名或簡單屬性名 
         * @param o 物件 
         * @return  屬性值 
         * @throws Exception 
         */  
        private static  Object getFieldValueByNameSequence(String fieldNameSequence, Object o) throws Exception{  
              
            Object value=null;  
              
            //將fieldNameSequence進行拆分  
            String[] attributes=fieldNameSequence.split("\\.");  
            if(attributes.length==1){  
                value=getFieldValueByName(fieldNameSequence, o);  
            }else{  
                //根據屬性名獲取屬性物件  
                Object fieldObj=getFieldValueByName(attributes[0], o);  
                String subFieldNameSequence=fieldNameSequence.substring(fieldNameSequence.indexOf(".")+1);  
                value=getFieldValueByNameSequence(subFieldNameSequence, fieldObj);  
            }  
            return value;   
              
        }   
          
          
        /** 
         * @MethodName  : setFieldValueByName 
         * @Description : 根據欄位名給物件的欄位賦值 
         * @param fieldName  欄位名 
         * @param fieldValue    欄位值 
         * @param o 物件 
         */  
        private static void setFieldValueByName(String fieldName,Object fieldValue,Object o) throws Exception{  
              
                Field field=getFieldByName(fieldName, o.getClass());  
                if(field!=null){  
                    field.setAccessible(true);  
                    //獲取欄位型別  
                    Class<?> fieldType = field.getType();    
                      
                    //根據欄位型別給欄位賦值  
                    if (String.class == fieldType) {    
                        field.set(o, String.valueOf(fieldValue));    
                    } else if ((Integer.TYPE == fieldType)    
                            || (Integer.class == fieldType)) {    
                        field.set(o, Integer.parseInt(fieldValue.toString()));    
                    } else if ((Long.TYPE == fieldType)    
                            || (Long.class == fieldType)) {    
                        field.set(o, Long.valueOf(fieldValue.toString()));    
                    } else if ((Float.TYPE == fieldType)    
                            || (Float.class == fieldType)) {    
                        field.set(o, Float.valueOf(fieldValue.toString()));    
                    } else if ((Short.TYPE == fieldType)    
                            || (Short.class == fieldType)) {    
                        field.set(o, Short.valueOf(fieldValue.toString()));    
                    } else if ((Double.TYPE == fieldType)    
                            || (Double.class == fieldType)) {    
                        field.set(o, Double.valueOf(fieldValue.toString()));    
                    } else if (Character.TYPE == fieldType) {    
                        if ((fieldValue!= null) && (fieldValue.toString().length() > 0)) {    
                            field.set(o, Character    
                                    .valueOf(fieldValue.toString().charAt(0)));    
                        }    
                    }else if(Date.class==fieldType){  
                        field.set(o, new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(fieldValue.toString()));  
                    }else{  
                        field.set(o, fieldValue);  
                    }  
                }else{  
                    throw new ExcelException(o.getClass().getSimpleName() + "類不存在欄位名 "+fieldName);  
                }  
        }  
          
          
        /** 
         * @MethodName  : setColumnAutoSize 
         * @Description : 設定工作表自動列寬和首行加粗 
         * @param ws 
         */  
        private static void setColumnAutoSize(WritableSheet ws,int extraWith){  
            //獲取本列的最寬單元格的寬度  
            for(int i=0;i<ws.getColumns();i++){  
                int colWith=0;  
                for(int j=0;j<ws.getRows();j++){  
                    String content=ws.getCell(i,j).getContents().toString();  
                    int cellWith=content.length();  
                    if(colWith<cellWith){  
                        colWith=cellWith;  
                    }  
                }  
                //設定單元格的寬度為最寬寬度+額外寬度  
                ws.setColumnView(i, colWith+extraWith);  
            }  
              
        }  
          
        /** 
         * @MethodName  : fillSheet 
         * @Description : 向工作表中填充資料 
         * @param sheet     工作表  
         * @param list  資料來源 
         * @param fieldMap 中英文欄位對應關係的Map 
         * @param firstIndex    開始索引 
         * @param lastIndex 結束索引 
         */  
        private static <T> void fillSheet(  
                WritableSheet sheet,  
                List<T> list,  
                LinkedHashMap<String,String> fieldMap,  
                int firstIndex,  
                int lastIndex  
                )throws Exception{  
              
            //定義存放英文欄位名和中文欄位名的陣列  
            String[] enFields=new String[fieldMap.size()];  
            String[] cnFields=new String[fieldMap.size()];  
              
            //填充陣列  
            int count=0;  
            for(Entry<String,String> entry:fieldMap.entrySet()){  
                enFields[count]=entry.getKey();  
                cnFields[count]=entry.getValue();  
                count++;  
            }  
            //填充表頭  
            for(int i=0;i<cnFields.length;i++){  
                Label label=new Label(i,0,cnFields[i]);  
                sheet.addCell(label);  
            }  
              
            //填充內容  
            int rowNo=1;  
            for(int index=firstIndex;index<=lastIndex;index++){  
                //獲取單個物件  
                T item=list.get(index);  
                for(int i=0;i<enFields.length;i++){  
                    Object objValue=getFieldValueByNameSequence(enFields[i], item);  
                    String fieldValue=objValue==null ? "" : objValue.toString();  
                    Label label =new Label(i,rowNo,fieldValue);  
                    sheet.addCell(label);  
                }  
                  
                rowNo++;  
            }  
              
            //設定自動列寬  
            setColumnAutoSize(sheet, 5);  
        }  
          
    }  
 

該工具類有4個過載的匯出方法和1個匯入方法，大家可以根據實際情況進行選擇。

總結

匯入和匯出方法都是通過傳一個fieldMap引數（類的英文屬性和Excel的中文列頭的對應關係）來連線實體類和Excel的

匯出的時候可以選擇匯出到本地檔案系統或匯出到瀏覽器，也可以自定義每個工作表的大小

匯入的時候可以自定義業務主鍵組合uniqueFields，這樣就可以檢測Excel中是否有重複行了

來自：http://blog.csdn.net/wzwenhuan/article/details/18838821