java中poi解析excel（兼容07版本以上及以下：.xls和.xlsx格式）

 package com.genersoft.cbms.ysbz.ExcelDr.cmd;

 import com.genersoft.cbms.ysbz.ExcelDr.dao.ExcelDrDao;
 import com.genersoft.cbms.ysbz.ExcelDr.dao.IExcelDrDao;
 import com.genersoft.cbms.ysbz.ExcelDr.domain.IExcelDrDomain;
 import com.genersoft.cbms.ysbz.ExcelDr.entity.ExcelDr;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.Row;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.Workbook;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.loushang.bsp.security.context.GetBspInfo;
 import org.loushang.bsp.share.organization.OrganFactory;
 import org.loushang.next.dao.DaoFactory;
 import org.loushang.next.data.DataSet;
 import org.loushang.next.data.ParameterSet;
 import org.loushang.next.data.Record;
 import org.loushang.next.upload.UploadFile;
 import org.loushang.next.web.cmd.BaseAjaxCommand;
 import org.loushang.sca.ScaComponentFactory;

 import java.io.*;
 import java.net.ServerSocket;
 import java.util.*;

 /**
  * Created by lyx on 2016/10/18.
  */
 public class ExcelDrCommand extends BaseAjaxCommand {
     private static IExcelDrDomain excelDomain = ScaComponentFactory.getService(IExcelDrDomain.class, "excelDomain/excelDomain");
     IExcelDrDao exceldao = (IExcelDrDao) DaoFactory.getDao(ExcelDrDao.class.getName());

     String dynm;

     /**
      * excel导入
      */
     public void importExcel() {
         //用来存插到bzsj表里的数据
         //List<ExcelDr> itemList = new ArrayList<ExcelDr>();
         ExcelDr item = new ExcelDr();

         //获取用户名称
         String organ_id = GetBspInfo.getBspInfo().getCorporationOrganId();//组织ID
         String organ_name;
         if (organ_id == null) {
             organ_name = "%";
         } else {
             organ_name = OrganFactory.getIOrganProvider().getOrganByOrganId(organ_id).getOrganName();//组织名称
         }
         item.setFcsjUser(organ_id);

        String slnm = (String) getParameter("slnm");
         item.setFcsjSlnm(slnm);
         //前台选中的组织的内码编号和名称
         String zznm = (String) getParameter("zznm");
         String zzbh = (String) getParameter("zzbh");
         String zzmc = (String) getParameter("zzmc");
         //是否选中按组织导入
         Boolean ifcheck = (Boolean) getParameter("ifcheck");
         //前台选中的目标类型的内码编号和名称
         String faMblx = (String) getParameter("faMblx");
         String mblxmc = (String) getParameter("mblxmc");
         String mblxbh = (String) getParameter("mblxbh");
         //获取前台选中了哪些报表
         String[] bbbhs = (String[]) getParameter("bbbhs");

         //不按组织导入时，获取前台选中了哪些组织
         String[] zzbhs = (String[]) getParameter("zzbhs");

         //解析excel
         Record[] records = (Record[]) getParameter("records");
         if (records == null || records.length < 1)
             return;
         Record record = records[0];
         UploadFile file = (UploadFile) record.get("file");
         InputStream inputStream = null;
         try {
             inputStream = file.getInputStream();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         // 得到工作表
         if (inputStream == null) {
             return;
         }
         //文件名
         String url = file.getFileName();
         //文件的后缀名
         String suffix = url.substring(url.lastIndexOf("."));
         // HSSFWorkbook book = null;
         Workbook book=null;
 /*        try {
             //如果是xlsx格式，则这一步会报错
             book = new HSSFWorkbook(inputStream);
         } catch (IOException e) {
             e.printStackTrace();
         }*/
         try {
             if(".xls".equals(suffix)){
                 //支持07版本以前的excel
                 book= new HSSFWorkbook(inputStream);
             }else if(".xlsx".equals(suffix)){
                 //支持07版本以后的excel
                 book = new XSSFWorkbook(inputStream);
             }else{
                 System.out.println("不支持的文件类型！");
                 return;
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
         if (book == null) {
             return;
         }
         //得到一共有几个sheet
         int sheetnum = book.getNumberOfSheets();

         //sheet页循环
         for (int i = 0; i < sheetnum; i++) {
             boolean ifbbexist = false;
             boolean ifzzexist = false;
             boolean ifbbzzexist = false;
             Sheet sheet = null;
             sheet = book.getSheetAt(i);
             if (sheet != null) {
                 //获取sheet页的名称
                 String sheetName = sheet.getSheetName();
                 //获取报表中的最后一行的行号，则总行数等于它加1
                 int allrow = sheet.getLastRowNum() + 1;

                 String sheetzzbh = "";
                 String[] sheetnmmc = new String[2];
                 if (ifcheck) {
                     //如果是安组织导入，将得到的sheet页名称分开，以便获取报表编号
                     String[] sheetNames = sheetName.split("\\.");
                     String bbbh = sheetNames[0];
                     for (int n = 0; n < bbbhs.length; n++) {
                         if (bbbh.equals(bbbhs[n])) {
                             ifbbexist = true;
                         }
                     }
                     if (ifbbexist) {
                         dynm = getDynm(bbbh);
                         item.setFcsjZznm(zznm);
                         item.setFcsjZzbh(zzbh);
                         item.setFcsjZzmc(zzmc);
                     }
                 } else {
                     //将得到的sheet页名称分开，以便获取报表编号
                     String[] sheetNames = sheetName.split("\\.");
                     String bbbh = sheetNames[0];
                     //将得到的sheet页名称分开，以便获取组织编号
                     sheetzzbh = sheetNames[1].substring(sheetNames[1].indexOf("(") + 1, sheetNames[1].indexOf(")"));
                     //判断此sheet页的报表编号是否是选中的
                     for (int b = 0; b < bbbhs.length; b++) {
                         if (bbbh.equals(bbbhs[b])) {
                             ifbbexist = true;
                         }
                     }
                     //判断此sheet页的组织编号是否是选中的
                     for (int z = 0; z < zzbhs.length; z++) {
                         if (sheetzzbh.equals(zzbhs[z])) {
                             ifzzexist = true;
                         }
                     }
                     if (ifbbexist && ifzzexist) {
                         ifbbzzexist = true;
                         dynm = getDynm(bbbh);
                         sheetnmmc = getZznmmc(sheetzzbh);
                         item.setFcsjZznm(sheetnmmc[0]);
                         item.setFcsjZzbh(sheetzzbh);
                         item.setFcsjZzmc(sheetnmmc[1]);
                     }
                 }
                 //1.(按组织导入）如果sheet页中的报表编号跟前台选中的编号相等，才能导入
                 //2.(不按组织导入）sheet页中的报表编号和组织编号跟前台选中的编号相等，才能导入
                 if ((ifbbexist && ifcheck) || ifbbzzexist) {
                   //获取该报表是否是两栏表头的表格
                   List<String> zhcs = getIfzh(dynm);
                    String ifzh = zhcs.get(0);
                   String kzhs = zhcs.get(1);
                   int kzh = Integer.parseInt(kzhs);
                   //获取该报表数据库里一共有几列
                    int tableCol = getTableCol(dynm);
                     //获取内容行从哪一行开始
                     int rownum = getRownum(dynm);
                     //内容行的行号（从1开始）
                   String mxnm = getMxnm(dynm);
                   DataSet dsc = getSjl(dynm);
                   DataSet dsr = getXxl(dynm);
                   int xxls = getXxls(dynm);
                   int hzbbStat = getStat(dynm, item);
                   //编制行里的行记录
                   List<HashMap<String, Object>> recordsList = getRecList(dynm,mxnm,item);

                   int footerRow = getFooternum(dynm);

                   //两栏表
                   if(ifzh.equals("1")){
                     int rowXh = 1;
                     for (int j = rownum; j < rownum+kzh-1; j++) {
                        int firstLan =1;
                       //cell单元格的值
                       String value = "";
                       Map<Integer, String> dataMap = new HashMap<Integer, String>();
                       int col = 0;
                       // 得到j的那一行
                       Row rowi = sheet.getRow(j);
                       // 得到该行的所有列
                       Iterator<Cell> cellTitle = rowi.cellIterator();
                       // 循环标题所有的列
                       while (cellTitle.hasNext()) {
                         if(0<firstLan && firstLan<=tableCol){
                           Cell cell = (Cell) cellTitle.next();
                           int type = cell.getCellType();
                           switch (type) {
                             case 0:
                               Double dValue = (Double) cell.getNumericCellValue();
                               value = dValue.toString();
                               break;
                             case 1:
                               value = cell.getStringCellValue();
                               break;
                             case 3:
                               value = "";
                               break;
                           }
                           dataMap.put(col, value);
                           col++;
                         }else{
                           break;
                         }
                         firstLan++;
                       }
                       Date date = new Date();
                       item.setCreatedtime(date);
                       item.setLastmodifiedtime(date);
                       exceldao.importExcel(dynm, dataMap, item, rowXh,mxnm,recordsList,xxls,hzbbStat,dsc,dsr);
                       rowXh++;
                     }
                     for (int j = rownum; j <= rownum+recordsList.size()-kzh; j++) {
                       int secontLan =1;
                       //cell单元格的值
                       String value = "";
                       Map<Integer, String> dataMap = new HashMap<Integer, String>();
                       int col = 0;
                       // 得到j的那一行
                       Row rowi = sheet.getRow(j);
                       // 得到该行的所有列
                       Iterator<Cell> cellTitle = rowi.cellIterator();
                       // 循环标题所有的列
                       while (cellTitle.hasNext()) {
                           Cell cell = (Cell) cellTitle.next();
                         if(tableCol<secontLan && secontLan<=tableCol*2){
                           int type = cell.getCellType();
                           switch (type) {
                             case 0:
                               Double dValue = (Double) cell.getNumericCellValue();
                               value = dValue.toString();
                               break;
                             case 1:
                               value = cell.getStringCellValue();
                               break;
                             case 3:
                               value = "";
                               break;
                           }
                           dataMap.put(col, value);
                           col++;
                         }
                         if(secontLan>tableCol*2){
                           break;
                         }
                         secontLan++;
                       }
                       Date date = new Date();
                       item.setCreatedtime(date);
                       item.setLastmodifiedtime(date);
                       exceldao.importExcel(dynm, dataMap, item, rowXh,mxnm,recordsList,xxls,hzbbStat,dsc,dsr);
                       rowXh++;
                     }
                   }else{
                     int rowXh = 1;
                     //正常表
                     for (int j = rownum; j < rownum+recordsList.size(); j++) {
                       //cell单元格的值
                       String value = "";
                       Map<Integer, String> dataMap = new HashMap<Integer, String>();
                       int col = 0;
                       // 得到j的那一行
                       Row rowi = sheet.getRow(j);
                       // 得到该行的所有列
                       Iterator<Cell> cellTitle = rowi.cellIterator();
                       // 循环标题所有的列
                       while (cellTitle.hasNext()) {
                         Cell cell = (Cell) cellTitle.next();
                 /*  cell.getCellType()返回的类型：
                     int CELL_TYPE_NUMERIC = 0;
                     int CELL_TYPE_STRING = 1;
                     int CELL_TYPE_FORMULA = 2;
                     int CELL_TYPE_BLANK = 3;
                     int CELL_TYPE_BOOLEAN = 4;
                     int CELL_TYPE_ERROR = 5;*/
                         int type = cell.getCellType();
                         switch (type) {
                           case 0:
                             Double dValue = (Double) cell.getNumericCellValue();
                             value = dValue.toString();
                             break;
                           case 1:
                             value = cell.getStringCellValue();
                             break;
                           case 3:
                             value = "";
                             break;
                         }
                         dataMap.put(col, value);
                         col++;
                       }
                       Date date = new Date();
                       item.setCreatedtime(date);
                       item.setLastmodifiedtime(date);
                       exceldao.importExcel(dynm, dataMap, item, rowXh,mxnm,recordsList,xxls,hzbbStat,dsc,dsr);
                         /*exceldao.importExcel(dynm,value,item);*/
                       rowXh++;
                     }
                   }
                 }
             }
         }
     }

     //获取报表的对应内码
     public String getDynm(String bbbh) {
         String txnm = (String) getParameter("txnm");
         return exceldao.getDynm(txnm, bbbh);
     }
   public String getMxnm(String dynm) {
     return exceldao.getMxnm(dynm);
   }

   //获取报表是否两栏表头
   public   List<String> getIfzh(String dynm){
     return exceldao.getIfzh(dynm);
   }
   //获取报表一共有几列
   public  int getTableCol(String dynm){
     return exceldao.getTableCol(dynm);
   }

   //根据sheet的组织编号获取组织的内码和名称
     public String[] getZznmmc(String sheetzzbh) {
         String txnm = (String) getParameter("sheetzzbh");
         return exceldao.getZznmmc(sheetzzbh);
     }

     //确定报表从第几行开始才是数据行（内容行）
     public int getRownum(String dynm) {
         return exceldao.getRownum(dynm);
     }
   public DataSet getSjl(String dynm) {
     return exceldao.getSjl(dynm);
   }
   public DataSet getXxl(String dynm) {
     return exceldao.getXxl(dynm);
   }
   public int getXxls(String dynm) {
     return exceldao.getXxls(dynm);
   }
   public int getStat(String dynm,ExcelDr item) {
     return exceldao.getStat(dynm,item);
   }

   //确定报表从第几行开始才是数据行（内容行）
   public int getFooternum(String dynm) {
     return exceldao.getFooternum(dynm);
   }
   public List<HashMap<String, Object>> getRecList(String dynm,String mxnm,ExcelDr item) {
     return exceldao.getRecList(dynm,mxnm,item);
   }

     /**
      * @param
      * @return void    返回类型
      * @throws
      * @Title: getCS
      * @Description: 获取当前用户所属组织的信息
      */
     public void getCS() {

         String organ_id = GetBspInfo.getBspInfo().getCorporationOrganId();//组织ID

         if (organ_id == null) {
             setReturn("organ_id", "%");
         } else {
             String organ_name = OrganFactory.getIOrganProvider().getOrganByOrganId(organ_id).getOrganName();//组织姓名
             setReturn("organ_id", organ_id);
         }
     }

     public void getParentOrgans() {
         String organId = (String) getParameter("organId");
         List<String> parentOrgans = new ArrayList<String>();
         parentOrgans = exceldao.getParentOrgans(organId);
         setReturn("organList", parentOrgans);
     }
   public void getFaslnm(){
     ParameterSet pset = getParameterSet();
     String faslnm=  exceldao.getFaslnm(pset);
     setReturn("faslnm", faslnm);
   }
 }

这些代码，必须要引入相应jar包才可以。