Java解析Excel之應用Reflection等技術實現動態讀取

 目錄樹

• 背景
• 技術選型
• 問題分析
• 技術要點及難點分析
• 源碼分析
• 測試用例

 

---

 

背景

Tip：因為產品提的需求我都開發完了，進行了項目提測；前天老大走過來說：你用spring-boot開發一個解析Excel的jar包.....詳細對話如下：

A：世生，你用spring-boot開發一個解析Excel的jar包。

B：為什么不在原來的項目上進行開發呢？(很納悶，這個東西不是一般用於前端上傳數據的嘛，這是后端層，咋搞這個)

A：因為xxxx這個需求有比較多的數據需要初始化，這個jar是作為一個上線的數據初始化腳本

B：嗯，好的

 

---

 

技術選型

 　　畢竟是第一次寫解析Excel代碼，問了度娘說是有兩種方式可以做到。一是利用wso2的jxl解析，二是利用apache的poi解析；我去maven repository官網搜索了這兩個jar包，對比了下jml的最新版本是2.6.12竟然是2011.05月更新的，而poi的最新版本是4.0.x是2018.08更新的；個人覺得jml最新版本都是2011.05更新的,相對於apache的poi包來說更不靠譜；不斷持續更新的開源項目或者開源jar包不管是bug還是兼容性相對來說是越來越好。所以最終選定用apache大佬的poi進行開發。

 

---

 

問題分析

　　解析Excel的關鍵點是在於從Excel表格中讀取數據到內存(解析Excel)，然后可能是校驗數據、通過業務邏輯分析數據、最終持久化到數據庫中；其實這其中最重要的不是解析Excel，而是將解析出的數據持久化到數據庫中以備有用之需。而解析Excel的這塊功能只能算是一個Util類，不能與業務代碼耦合一起；然后我看到很多的Excel解析相關的代碼都是在解析數據中混淆業務代碼邏輯，其實這些都是不可取的，這會導致解析Excel邏輯與業務邏輯相耦合也就是冗雜、代碼重用率低、可擴展性低等問題。因為之前在做項目的時候遇到過一個問題：我負責的模塊是一個中間模塊(通訊采用Dubbo)，其他系統要依賴我這個接口進行請求的轉發可我調用其他系統返回的結果對象卻各個都不同，我叫其他系統負責人說要統一調用接口返回的對象，但是其他系統的負責人都不是同一個人執行起來效率太低了，在歷經一個星期都無果的情況下我只能撒下自己的殺手鐧了；在這種極端條件下最終我不管其他數據的接口返回的對象是什么，我直接用Object接收返回類型，通過反射獲取決定請求成功與否的屬性值(欣慰的是當時必傳屬性值倒是一樣的)。通過這種方法我可以少些很多的代碼（當時其他系統有15+），不然的話每調用不同系統的接口我都需要進行邏輯判斷或者是干脆對於調用他們不同的系統我采用不同接口進行轉發，但選用這種方法卻便利多了。

　　以上問題分析及一個場景的描述很好理解，但是通過Object接收返回信息得這個場景事實上卻有所欠佳；返回對象不同的這個問題最好的處理方案就是統一接口，我那個方案是在需求推動但別人無法及時配合的極端條件下使用的，是沒辦法中的辦法，但這也是一個沒有辦法中的一個最優的處理方案，兼容性比較強。以下我就用圖來分析這兩種情況的比較：

　　1.非動態模式：將Excel數據加載到內存與業務代碼邏輯混合，數據在解析期間交叉傳遞。弊端：每新增一個需要解析的Excel，解析Excel代碼塊就需要重新開發，代碼復用率底下、可擴展性也低。

　　

 

　　2.動態模式：將Excel數據加載到內存與業務代碼邏輯分開；Excel數據加載到內存之后才將數據傳遞給業務代碼邏輯處理，解析Excel與業務代碼之間分開；優點：將解析Excel的這部分代碼封裝為一個ExcelUtil，代碼復用率明顯提高，而且解析與業務代碼間實行解耦，可擴展性增強。

       

---

 

技術要點及難點分析

　　要實現動態解析，實現解析與業務代碼邏輯相解耦；那么我們不難會想起一個Java的一個關鍵技術-Reflection(反射原理)，Python、Ruby等是動態語言而理論上Java是一門靜態語言，但是Java引入了Reflection技術實現了動態性。反射原理我們都比較熟悉，就是在運行期間動態獲取類的所有屬性及其方法，可以對這些數據進行相關的操作。以上動態解析Excel的實現就需要用到Java這項的高級技術了，通過這項技術可以實現動態解析、解析與業務邏輯解耦等。為了實現動態解析的目的我應用了Java反射技術，但是在開發的過程我發現反射執行一行數據結束的時候如何保存呢？換句話說就是：解析的時候一行的Excel數據封裝后就是一個bean，一個Excel表格就是多個bean 即“beans”；如果我們直接將反射執行后的結果保存至List中，當解析整個Excel結束后我們會發現，整個List里面的對象的值完全一樣的？what？這是什么原因導致的呢？這就是類似於：Object obj=new Object()，我們每次解析都只是把 obj 放在List中，List中的每一個對象都是同一個 obj(引用不變，實例也不變)，所以自然也就相同了；因為當一個類執行反射的時候其實它的運行時狀態只有一個，也就是類似於只有一個實例，而傳統的解析Excel是解析出一條數據就new一個對象進行封裝數據，然后將bean存放至List。然而有什么方法能夠解決這一類問題呢？那就是Object 的native clone()方法了，clone()這個大佬是比較牛逼的一個人物，在不創建對象的情況下將屬性值復制給另一個對象，具體實現需要實現Cloneable接口並重寫clone()。而解決這個問題的方式就是在每解析完一行Excel數據的時候，反射調用該對象的clone方法。動態解析具體實現應用了Apache POI、 LRUCache(LRU緩存)、Reflection(反射)、java的Clone等技術。如果以上技術沒有了解過的朋友可以去自行了解，這里不加贅述。

　　前提條件：因為要實現動態解析，動態設置值，那么我們在反射執行set操作的時候就需要知道相應的setMethod()，那么我們可以在Excel規定第一行就是屬性字段，並且字段名稱跟bean的名稱一樣，讀取的時候先把第一行的數據放在一個String []數組中。具體實現請參照以下源碼。我已經把相關代碼打包成Jar，需要的朋友可以自行下載；Jar包Git下載地址：https://github.com/GitHubSuper543/auto-resolver-excel-jar.git，源碼地址：https://github.com/GitHubSuper543/auto-resolver-excel-resource.git

　　使用方法：新建bean用於存儲Excel數據信息，每個屬性需要有get、set操作，屬性與Excel首行相同，最重要的一點是要實現Clonesble接口重寫clone方法。Excel使用Office編輯，親測Wps編輯的Excel某些屬性值有問題。在new ReadExcelUtil 的時候只需要將對象類型與Excel文件路徑傳入構造函數即可，然后調用 ReadExcelUtil的getObjectList即可得到解析后的所有對象。至於這個對象你可以用任何的對象，你可以換成Teacher、OrderInfo、UserInfo......但是前面提到的：Excel第一行的屬性字段需要與bean的屬性字段一致，否則無法調用目標方法，具體可參見ReflectionInitValue的方法。具體實現請參見：文章末尾的Test類測試。　

 

---

 

 源碼分析

• 前提條件：引入Apache POI 的Maven倉庫坐標，我這里使用的是3.25版本的。
  

 

 1 <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>3.15</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.15</version>
</dependency>

 

• 主要類：Common.java、LRUCache.java、LRUCacheException.java、ResolveFileException.java、ReadExcelUtil.java、ReflectionInitValue.java、Student、Test

• Common.java：基礎常量池，主要用於反射執行Method方法時判斷Method的參數類型的常量。

 

package com.hdbs.common;

/**
 * @author :cnblogs-WindsJune
 * @version :1.1.0
 * @date :2018年9月20日 下午6:33:54
 * @comments :解析Excel公共類常量類
 */

public class Common {
    
    public static final String OFFICE_EXCEL_2003_POSTFIX_xls = "xls";
    public static final String OFFICE_EXCEL_2010_POSTFIX_xlsx = "xlsx";
    public static final String DATA_TYPE_long ="long";
    public static final String DATA_TYPE_boolean ="boolean";
    public static final String DATA_TYPE_int ="int";
    public static final String DATA_TYPE_float ="float";
    public static final String DATA_TYPE_double ="double";
    public static final String DATA_TYPE_Long ="class java.lang.Long";
    public static final String DATA_TYPE_Integer ="class java.lang.Integer";


}

 

 

• LRUCacheException.java；LRU緩存自定義異常類。

package com.hdbs.exceptions;

/**
 * Creater: cnblogs-WindsJune
 * Date: 2018/9/21
 * Time: 10:04
 * Description: No Description
 */
public class LRUCacheException extends  Exception{
    /**
     * 錯誤碼
     */
    private String errorCode;

    /**
     * 錯誤描述
     */
    private String errorMessage;

    public LRUCacheException(String errorCode, String errorMessage) {
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }

    public LRUCacheException(String message) {
        super(message);
        this.errorMessage = errorMessage;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public void setErrorMessage(String errorMessage) {
        this.errorMessage = errorMessage;
    }
}

 

• ResolveFileException.java；解析Excel自定義異常類。

 

package com.hdbs.exceptions;
/**
 * Creater: cnblogs-WindsJune
 * Date: 2018/9/20
 * Time: 19:44
 * Description: 解析Excel的公共異常類
 */

public class ResolveFileException extends RuntimeException{

    /**
     * 錯誤碼
     */
    private String errorCode;

    /**
     * 錯誤描述
     */
    private String errorMessage;

    public ResolveFileException(String errorCode, String errorMessage) {
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }

    public ResolveFileException(String message) {
        super(message);
        this.errorMessage = errorMessage;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public void setErrorMessage(String errorMessage) {
        this.errorMessage = errorMessage;
    }
}

 

 

• LRUCache.java：LRU緩存池，主要用於不同線程反射獲取的Methods，減少相同線程反射執行次數，減輕應用的負載、提高執行效率。我這里是基於LinkedHashMap實現的LRU緩存，你也可以用數組或者其他方式實現該算法。以下代碼邏輯如果不能理解的可以先去了解LinkedHashSet的源碼。

 

package com.hdbs.common;

import com.hdbs.exceptions.LRUCacheException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Method;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Creater: cnblogs-WindsJune
 * Date: 2018/9/20
 * Time: 19:44
 * Description: LinkedHashMap實現LRU緩存不同線程反射獲取的Method方法
 */
public class LRUCache {
    private  static  final Logger LOGGER=LoggerFactory.getLogger(LRUCache.class);
    //緩存容量
    private static final int cacheSize = 10;

    private static final Map<Integer,Method[]> cacheMap = new LinkedHashMap<Integer, Method[]>((int) Math.ceil(cacheSize / 0.75f) + 1, 0.75f, true){
        @Override
        protected boolean removeEldestEntry(Map.Entry<Integer,Method[]> eldest){

            return  size()> cacheSize;
            
        }
    };

    /**
     * 設置緩存
     * @param key
     * @param methods
     * @return boolean
     */
    public static boolean set (Integer key,Method [] methods) throws LRUCacheException {
        try {
               cacheMap.put(key,methods);
               return true;
        }
        catch ( Exception e ){
              throw new LRUCacheException("Set LRU緩存異常！");
        }
    }

    /**
     * 獲取緩存的Method
     * @param key
     * @return Method
     */
    public static Method[] get(Integer key) throws LRUCacheException {
        Method[] methods=null;
        try {
            methods=cacheMap.get(key);
        }catch ( Exception e ){
               throw new LRUCacheException("Get LRU緩存異常！{}");
        }
        return methods;
    }
}

 

 

• ReadExcelUtil.java；解析Excel數據工具類(將Excel加載到內存)

 

package com.hdbs.resolver;

import com.hdbs.common.Common;
import com.hdbs.exceptions.ResolveFileException;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author :cnblogs-WindsJune
 * @version :1.1.0
 * @date :2018年9月20日 下午6:13:43
 * @comments :
 */

public class ReadExcelUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(ReadExcelUtil.class);
　　//存放屬性集
    private  Map<Integer,String []> fieldsMap=new HashMap<>();
　　//存放解析后的對象List
    private List<Object> objectsList = new ArrayList<>();
　　//反射運行時對象
    private Object object=null;
　　//Excel文件路徑
    private  String path =null;
　　//獲取解析后的對象集
    public List<Object> getObjectsList() {
        return this.objectsList;
    }

    public ReadExcelUtil(Object object,String path) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException, IOException {
        this.object=object;
        this.path=path;
        readExcel();
    }

    /**
     * 添加Object到List中
     * @param object
     * @return
     */
    public boolean addListObject(Object object){
        boolean isSucceed=this.objectsList.add(object);
        return  isSucceed;
    }

    /**
     * 讀取excel,判斷是xls結尾(2010之前)；還是xlsx結尾(2010以后)的Excel
     * 
     * @return
     * @throws IOException
     */
    public boolean readExcel() throws IOException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        if (StringUtils.isEmpty(path)) {
            return false;
        } else {
            // 截取后綴名，判斷是xls還是xlsx
            String postfix = path.substring(path.lastIndexOf(".") + 1);
            if (!StringUtils.isEmpty(postfix)) {
                if (Common.OFFICE_EXCEL_2003_POSTFIX_xls.equals(postfix)) {
                    return readXls();
                } else if (Common.OFFICE_EXCEL_2010_POSTFIX_xlsx.equals(postfix)) {
                    return readXlsx();
                }
            } else {
                LOGGER.error("文件后綴名有誤！");
                throw new ResolveFileException("文件后綴名有誤！" + "[" + path + "]");
            }
        }
        return false;
    }

    /**
     * 讀取xls(2010)之后的Excel
     * 
     * @return
     * @throws IOException
     */
    public  boolean readXlsx() throws IOException{
        File file = new File(path);
        InputStream is = new FileInputStream(file);
        XSSFWorkbook xssfWorkbook = new XSSFWorkbook(is);
        // 遍歷sheet頁
        for (int numSheet = 0; numSheet < xssfWorkbook.getNumberOfSheets(); numSheet++) {
            XSSFSheet xssfSheet = xssfWorkbook.getSheetAt(numSheet);
            String [] fields=null;
            if (xssfSheet == null) {
                continue;
            }
            // 循環行
            for (int rowNum = 0; rowNum <= xssfSheet.getLastRowNum(); rowNum++) {
                XSSFRow xssfRow = xssfSheet.getRow(rowNum);
                int cloumns=xssfRow.getLastCellNum();
                int i=0;
                //獲取第一行的所有屬性
                if (rowNum == 0){
                    fields=getFields(xssfRow,cloumns);
                    fieldsMap.put(numSheet,fields);
                    continue;
                }
                //遍歷數據,反射set值
                while (i<cloumns){
                    XSSFCell field=xssfRow.getCell(i);
                    String value=getValue(field);
                    try {
                        ReflectionInitValue.setValue(object,fields[i],value);
                    }catch ( Exception e ){
                        throw new ResolveFileException(e.getMessage());
                    }
                    i++;
                }
                //通過反射執行clone復制對象
                Object result=ReflectionInitValue.invokeClone(object,"clone");
                this.addListObject(result);
               // System.out.println(object.toString());
            }
        }
        return true;
    }

    /**
     * 讀取xls(2010)之前的Excel
     * 
     * @return
     * @throws IOException
     */
    public boolean readXls() throws IOException, ResolveFileException {
        InputStream is = new FileInputStream(path);
        HSSFWorkbook hssfWorkbook = new HSSFWorkbook(is);
        // 遍歷sheet頁
        for (int numSheet = 0; numSheet < hssfWorkbook.getNumberOfSheets(); numSheet++) {
            HSSFSheet hssfSheet = hssfWorkbook.getSheetAt(numSheet);
            String[] fields = null;
            if (hssfSheet == null) {
                continue;
            }
            // 循環行Row
            for (int rowNum = 0; rowNum <= hssfSheet.getLastRowNum(); rowNum++) {
                HSSFRow hssfRow = hssfSheet.getRow(rowNum);
                int cloumns=hssfRow.getLastCellNum();
                int i=0;
                //獲取第一行的所有屬性
                if (rowNum == 0){
                    //獲取屬性字段
                    fields=getFields(hssfRow,cloumns);
                    fieldsMap.put(numSheet,fields);
                    continue;
                }
                //遍歷數據,反射set值
                while (i<cloumns){
                    HSSFCell field=hssfRow.getCell(i);
                    String value=getValue(field);
                    try {
                        ReflectionInitValue.setValue(object,fields[i],value);
                    }catch ( Exception e ){
                        throw  new ResolveFileException(e.getMessage());
                    }
                    i++;
                }
                //通過反射執行clone復制對象
                Object result=ReflectionInitValue.invokeClone(object,"clone");
                this.addListObject(result);
            }
        }
        return true;
    }

    /**
     * xlsx -根據數據類型，獲取單元格的值
     * @param xssfRow
     * @return
     */
    @SuppressWarnings({ "static-access" })
    private static String getValue(XSSFCell xssfRow) {
        String value=null;
        try {
            if (xssfRow.getCellType() == xssfRow.CELL_TYPE_BOOLEAN) {
                // 返回布爾類型的值
                value=String.valueOf(xssfRow.getBooleanCellValue()).replace(" ","");
            } else if (xssfRow.getCellType() == xssfRow.CELL_TYPE_NUMERIC) {
                // 返回數值類型的值
                value= String.valueOf(xssfRow.getNumericCellValue()).replace(" ","");
            } else {
                // 返回字符串類型的值
                value= String.valueOf(xssfRow.getStringCellValue()).replace(" ","");
            }
        } catch (Exception e) {
            //單元格為空，不處理
            value=null;
            LOGGER.error("單元格為空！");
        }
        return value;
    }

    /**
     * xls-根據數據類型，獲取單元格的值
     * @param hssfCell
     * @return
     */
    @SuppressWarnings({ "static-access" })
    private static String getValue(HSSFCell hssfCell) {
        String value=null;
        try {
            if (hssfCell.getCellType() == hssfCell.CELL_TYPE_BOOLEAN) {
                // 返回布爾類型的值
                value=String.valueOf(hssfCell.getBooleanCellValue()).replaceAll(" ","");
            } else if (hssfCell.getCellType() == hssfCell.CELL_TYPE_NUMERIC) {
                // 返回數值類型的值
                value=String.valueOf(hssfCell.getNumericCellValue()).replaceAll(" ","");
            } else {
                // 返回字符串類型的值
                value=String.valueOf(hssfCell.getStringCellValue()).replaceAll(" ","");
            }
        } catch (Exception e) {
            //單元格為空，不處理
            value=null;
            LOGGER.error("單元格為空！");
        }
        return value;
    }

    /**
     * xls Excel文件類型獲取屬性（2010之前）
     * @param cloumns
     * @return String[]
     */
    private  static String[] getFields (HSSFRow hssfRow,int cloumns){
        String [] fields=new String[cloumns];
        int i=0;
        try {
            while (i<cloumns){
                HSSFCell field=hssfRow.getCell(i);
                String value=getValue(field);
                fields[i]=value.trim();
                i++;
            }
        }catch ( Exception e){
            throw  new ResolveFileException("獲取屬性集失敗！");
        }
        return  fields;
    }

    /**
     * xlsx Excel文件類型獲取屬性（2010之后）
     * @param cloumns
     * @return String[]
     */
    private  static String[] getFields(XSSFRow xssfRow,int cloumns){
        String [] fields=new String[cloumns];
        int i=0;
        try {
            while (i<cloumns){
                XSSFCell field=xssfRow.getCell(i);
                String value=getValue(field);
                fields[i]=value.trim();
                i++;
            }
        }catch ( Exception e ){
            throw  new ResolveFileException("獲取屬性集失敗！");
        }
        return  fields;
    }

}

 

• ReflectionInitValue.java；

package com.hdbs.resolver;

import com.hdbs.common.Common;
import com.hdbs.common.LRUCache;
import com.hdbs.exceptions.LRUCacheException;
import com.hdbs.exceptions.ResolveFileException;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;

/**
 * Creater: cnblogs-WindsJune
 * Date: 2018/9/21
 * Time: 9:54
 * Description: No Description
 */
public class ReflectionInitValue {

    private static int threadHashCodeKey=Thread.currentThread().toString().hashCode();

    /**
     * 通過反射動態將Excel讀取的信息設置到對應的bean中
     *
     * @param object-存儲對象bean
     * @param key-屬性參數名
     * @param value-屬性值
     * @throws Exception
     */
    public static void setValue(Object object, String key, String value) throws LRUCacheException {
        String methodName = null;
        String paramType = null;
        Method[] methods = null;
        if (LRUCache.get(threadHashCodeKey) == null) {
            Class<?> clazz = object.getClass();
            methods = clazz.getDeclaredMethods();
            LRUCache.set(threadHashCodeKey, methods);
        } else {
            methods = LRUCache.get(threadHashCodeKey);
        }
        for (Method method : methods) {
            methodName = method.getName();
            if (methodName.startsWith("set") && methodName.toLowerCase().equals("set" + key.toLowerCase())) {
                Type[] types = method.getGenericParameterTypes();
                for (Type type : types) {
                    paramType = type.toString();
                    // 根據參數類型轉化value，並進行set操作
                    excuteInvokeSetvalue(object, method, paramType, value, 0);
                }
                // 該屬性已經執行setValue操作，無需循環
                break;
            }
        }
    }

    /**
     * 初始化對象bean
     *
     * @param object
     * @throws Exception
     */
    public static void initBeans(Object object) throws ResolveFileException, LRUCacheException {
        // Class<?> clazz = object.getClass();
        String methodName = null;
        String paramType = null;
        Method[] methods = LRUCache.get(threadHashCodeKey);
        try {
            for (Method method : methods) {
                methodName = method.getName();
                if (methodName.startsWith("set")) {
                    Type[] types = method.getGenericParameterTypes();
                    for (Type type : types) {
                        paramType = type.getClass().getName();
                    }
                    // 根據參數類型轉化value，並進行set初始化屬性值
                    excuteInvokeSetvalue(object, method, paramType, "", 1);
                }
            }
        } catch (Exception e) {
            throw new ResolveFileException("初始化bean錯誤！Method:[ " + methodName + " ]");
        }
    }

    /**
     * 根據參數類型轉化value，並進行set操作
     *
     * @param object-存儲對象bean
     * @param method-執行的set對應屬性的方法
     * @param paramType-屬性參數類型
     * @param value-屬性值
     * @param operationType-操作類型(0-設置屬性，1-初始化bean)
     * @throws Exception
     */
    public static void excuteInvokeSetvalue(Object object, Method method, String paramType, String value,
                                             int operationType){
        try {
            switch (paramType) {
                case Common.DATA_TYPE_long: {// 參數屬性long
                    if (value !=null && value.contains(".")){
                        value=value.substring(0,value.lastIndexOf("."));
                    }
                    Long temp = Long.valueOf(operationType == 0 && value !=null ? value : "0");
                    method.invoke(object, temp);
                    break;
                }
                case Common.DATA_TYPE_boolean: {// 參數屬性boolean
                    boolean temp = (operationType == 0 ? (Boolean.valueOf(value != null ? value:"false")) : false);
                    method.invoke(object, temp);
                    break;
                }
                case Common.DATA_TYPE_int: {// 參數屬性int
                    if (value !=null && value.contains(".")){
                        value=value.substring(0,value.lastIndexOf("."));
                    }
                    int temp = Integer.valueOf(operationType == 0 && value!=null ? value : "0");
                    method.invoke(object, temp);
                    break;
                }
                case Common.DATA_TYPE_float: {// 參數屬性float
                    if (value !=null && value.contains(".")){
                        value=value.substring(0,value.lastIndexOf("."));
                    }
                    float temp = Float.valueOf(operationType == 0 && value !=null ? value : "0");
                    method.invoke(object, temp);
                    break;
                }
                case Common.DATA_TYPE_double: {// 參數屬性double
                    double temp = Double.valueOf(operationType == 0 && value !=null ? value : "0");
                    method.invoke(object, temp);
                    break;
                }
                case Common.DATA_TYPE_Long: {// 參數屬性Long
                    if (value !=null && value.contains(".")){
                        value=value.substring(0,value.lastIndexOf("."));
                    }
                    Long temp = Long.valueOf(operationType == 0 && value!=null ? value : "0");
                    method.invoke(object, temp);
                    break;
                }
                case Common.DATA_TYPE_Integer: {// 參數屬性Integer
                    if (value !=null && value.contains(".")){
                        value=value.substring(0,value.lastIndexOf("."));
                    }
                    int temp = Integer.valueOf(operationType == 0 && value!=null ? value : "0");
                    method.invoke(object, temp);
                    break;
                }
                default: {// 參數屬性String
                    if (value !=null && value.contains(".")){
                        value=value.substring(0,value.lastIndexOf("."));
                    }
                    method.invoke(object, operationType == 0 ? value : null);
                    break;
                }
            }

        } catch ( IllegalAccessException e ) {
            throw new ResolveFileException("invoke方法錯誤！[Method:" + method.getName() + " [value:" + value + " ]");
        } catch ( InvocationTargetException e ) {
            throw new ResolveFileException("invoke方法錯誤！[Method:" + method.getName() + " [value:" + value + " ]");
        } catch (Exception e) {
            throw new ResolveFileException("字段屬性錯誤！[Method:" + method.getName() + " [value:" + value + " ]");
        }


    }

    /**
     *
     * @param object
     * @param methodName
     * @return
     * @throws ResolveFileException
     */
    public static Object invokeClone (Object object,String methodName){
        Class clazz=object.getClass();
        try {
            Method method=clazz.getMethod(methodName);
            Object result=method.invoke(object);
            return  result;
        }catch ( Exception e ){
            throw new ResolveFileException("解析Excel，反射執行set操作異常！");
        }

    }


}

 

• Student.java；用於存儲數據信息得bean。

package com.hdbs.beans;

import java.util.ArrayList;
import java.util.List;

/**
 * @author :WindsJune/博客園：WindsJune
 * @version :1.1.0
 * @date :2018年9月20日 下午6:05:57
 * @comments :
 */

public class Student implements Cloneable{
    
    /**
     * id
     */
    private Integer id;
    /**
     * 學號
     */
    private String no;
    /**
     * 姓名
     */
    private String name;
    /**
     * 學院
     */
    private String age;
    /**
     * 成績
     */
    private float score;

    /**
     * 地址
     */
    private String adress;

    private List<Student> studentsList=new ArrayList<>();

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }

    public String getAdress() {
        return adress;
    }

    public void setAdress(String adress) {
        this.adress = adress;
    }

    public List<Student> getStudentsList() {
        return studentsList;
    }

    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", no='" + no + '\'' +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", score=" + score +
                ", adress='" + adress + '\'' +
                '}';
    }
}

 

• Test.java；測試方法，在new ReadExcelUtil 的時候只需要將對象類型與Excel文件路徑傳入構造函數即可，然后調用 ReadExcelUtil的getObjectList即可得到解析后的所有對象。至於這個對象你可以用任何的對象，你可以換成Teacher、OrderInfo、UserInfo......但是前面提到的：Excel第一行的屬性字段需要與bean的屬性字段一致，否則無法調用目標方法，具體可參見ReflectionInitValue的方法。

package hello;

import java.util.List;

import com.hdbs.beans.Student;
import com.hdbs.resolver.ReadExcelUtil;

/**
 * @version 1.0.0
 * @author  cnblogs-WindsJune
 * @date    2018年9月23日 上午1:16:34
 * 
 */
public class Test {
    public static void main(String[] args) {
        Student student=new Student();
        String filePath="E:/test.xlsx";
        try {
            ReadExcelUtil readExcelUtil=new ReadExcelUtil(student,filePath);
            List<Object> list=readExcelUtil.getObjectsList();
            for (Object object:list){
                Student test=(Student) object;
                System.out.println(test.toString());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

表格規范：

 

執行結果：