SpringBoot实现Excel读取的实例教程

前言

这是本人写的一个springboot对excel读取的方法，实测能用，待提升的地方有很多，有不足之处请多多指点。

excel2003版（后缀为.xls）最大行数是65536行，最大列数是256列。

excel2007以上的版本（后缀为.xlsx）最大行数是1048576行，最大列数是16384列。

提供2种方法读取：

1.根据指定的开始和结束行数读取返回结果，结果格式为list<map<string, object>>

2.根据指定的开始和结束行数读取返回结果，结果格式为list<pojo(传入的实体类)>

请根据实际内存堆可用大小进行读取，太多可进行分段读取（类似分页的原理）

读取excel所需要的几个类

1.在pom.xml加上依赖

</dependencies>
 <dependency>
  <groupid>org.apache.poi</groupid>
  <artifactid>poi</artifactid>
  <version>4.0.1</version>
 </dependency>
 <dependency>
  <groupid>org.apache.poi</groupid>
  <artifactid>poi-ooxml</artifactid>
  <version>4.0.1</version>
 </dependency>
</dependencies>

2.excelpojo实体类

package com.cly.utils.excel;

/**
 * @author : cly
 * @classname : excelpojo
 * @date : 2020/7/9 17:13
 * 实体类所有成员变量都需要有get,set方法
 * 所有成员变量都要加上注解@excelrescoure(value = "?"),?为excel真实列名，必须一一对应
 * @excelrescoure(value = "?"),?可为空,需要用到才赋值
 * 成员变量目前只允许string,double,interge,float
 **/

public class excelpojo {
 public string getname() {
 return name;
 }
 public void setname(string name) {
 this.name = name;
 }
 public string getpasswork() {
 return passwork;
 }
 public void setpasswork(string passwork) {
 this.passwork = passwork;
 }
 public string getlook() {
 return look;
 }
 public void setlook(string look) {
 this.look = look;
 }
 
 @excelrescoure(value = "xm")
 private string name;
 @excelrescoure(value = "sfzh")
 private string passwork;
 @excelrescoure()
 private string look;
 
 @override
 public string tostring(){
 return "name:"+this.getname()+",passwork:"+this.getpasswork()+",look:"+this.getlook();
 }
 public excelpojo() {}
}

3.@interface自定义注解(用于实体类读取)

package com.cly.utils.excel;

import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;

/**
 * @author : cly
 * @classname : myrescoure
 * @date : 2020/7/10 9:31
 **/
@target(elementtype.field)
@retention(retentionpolicy.runtime)
public @interface excelrescoure {
 string value() default "";//默认为空
}

4.excelread类（读取excel数据类）有很多冗余的代码，可抽离出来

package com.cly.utils.excel;

import com.alibaba.fastjson.json;
import com.alibaba.fastjson.jsonarray;
import com.alibaba.fastjson.jsonobject;
import com.sun.org.apache.bcel.internal.generic.new;
import org.apache.poi.hssf.usermodel.hssfworkbook;
import org.apache.poi.ss.formula.functions.t;
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.slf4j.logger;
import org.slf4j.loggerfactory;

import javax.xml.transform.source;
import java.beans.introspectionexception;
import java.beans.propertydescriptor;
import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.lang.reflect.*;
import java.text.decimalformat;
import java.util.*;

/**
 * @author : cly
 * @classname : excelread
 * @date : 2020/7/9 11:08
 **/
public class excelread {
 //日志输出
 private static logger logger = loggerfactory.getlogger(excelread.class);
 //定义excel类型
 private static final string xls = "xls";
 private static final string xlsx = "xlsx";

 /**
 * 根据文件后缀名类型获取对应的工作簿对象
 * @param inputstream 读取文件的输入流
 * @param filetype 文件后缀名类型（xls或xlsx）
 * @return 包含文件数据的工作簿对象
 */
 private static workbook getworkbook(inputstream inputstream, string filetype) throws ioexception {
 //用自带的方法新建工作薄
 workbook workbook = workbookfactory.create(inputstream);
 //后缀判断有版本转换问题
 //workbook workbook = null;
 //if (filetype.equalsignorecase(xls)) {
 // workbook = new hssfworkbook(inputstream);
 //} else if (filetype.equalsignorecase(xlsx)) {
 // workbook = new xssfworkbook(inputstream);
 //}
 return workbook;
 }


 /**
 * 将单元格内容转换为字符串
 * @param cell
 * @return
 */
 private static string convertcellvaluetostring(cell cell) {
 if (cell == null) {
  return null;
 }
 string returnvalue = null;
 switch (cell.getcelltype()) {
  case numeric: //数字
  double doublevalue = cell.getnumericcellvalue();
  // 格式化科学计数法，取一位整数，如取小数，值如0.0,取小数点后几位就写几个0
  decimalformat df = new decimalformat("0");
  returnvalue = df.format(doublevalue);
  break;
  case string: //字符串
  returnvalue = cell.getstringcellvalue();
  break;
  case boolean: //布尔
  boolean booleanvalue = cell.getbooleancellvalue();
  returnvalue = booleanvalue.tostring();
  break;
  case blank: // 空值
  break;
  case formula: // 公式
  returnvalue = cell.getcellformula();
  break;
  case error: // 故障
  break;
  default:
  break;
 }
 return returnvalue;
 }

 /**
 * 处理excel内容转为list<map<string,object>>输出
 * workbook：已连接的工作薄
 * statrrow：读取的开始行数（默认填0，0开始,传过来是excel的行数值默认从1开始，这里已处理减1）
 * endrow：读取的结束行数（填-1为全部）
 * existtop:是否存在头部（如存在则读取数据时会把头部拼接到对应数据，若无则为当前列数）
 */
 private static list<map<string, object>> handledata(workbook workbook, int statrrow, int endrow, boolean existtop) {
 //声明返回结果集result
 list<map<string, object>> result = new arraylist<>();
 //声明一个excel头部函数
 arraylist<string> top = new arraylist<>();
 //解析sheet（sheet是excel脚页）
 /**
 *此处会读取所有脚页的行数据，若只想读取指定页，不要for循环，直接给sheetnum赋值，脚页从0开始（通常情况excel都只有一页，所以此处未进行进一步处理）
 */
 for (int sheetnum = 0; sheetnum < workbook.getnumberofsheets(); sheetnum++) {
  sheet sheet = workbook.getsheetat(sheetnum);
  // 校验sheet是否合法
  if (sheet == null) {
  continue;
  }
  //如存在头部，处理头部数据
  if (existtop) {
  int firstrownum = sheet.getfirstrownum();
  row firstrow = sheet.getrow(firstrownum);
  if (null == firstrow) {
   logger.warn("解析excel失败，在第一行没有读取到任何数据！");
  }
  for (int i = 0; i < firstrow.getlastcellnum(); i++) {
   top.add(convertcellvaluetostring(firstrow.getcell(i)));
  }
  }
  //处理excel数据内容
  int endrownum;
  //获取结束行数
  if (endrow == -1) {
  endrownum = sheet.getphysicalnumberofrows();
  } else {
  endrownum = endrow <= sheet.getphysicalnumberofrows() ? endrow : sheet.getphysicalnumberofrows();
  }
  //遍历行数
  for (int i = statrrow - 1; i < endrownum; i++) {
  row row = sheet.getrow(i);
  if (null == row) {
   continue;
  }
  map<string, object> map = new hashmap<>();
  //获取所有列数据
  for (int y = 0; y < row.getlastcellnum(); y++) {
   if (top.size() > 0) {
   if (top.size() >= y) {
    map.put(top.get(y), convertcellvaluetostring(row.getcell(y)));
   } else {
    map.put(string.valueof(y + 1), convertcellvaluetostring(row.getcell(y)));
   }
   } else {
   map.put(string.valueof(y + 1), convertcellvaluetostring(row.getcell(y)));
   }
  }
  result.add(map);
  }
 }
 return result;
 }

 /**
 * 方法一
 * 根据行数和列数读取excel
 * filename:excel文件路径
 * statrrow：读取的开始行数（默认填0）
 * endrow：读取的结束行数（填-1为全部）
 * existtop:是否存在头部（如存在则读取数据时会把头部拼接到对应数据，若无则为当前列数）
 * 返回一个list<map<string,object>>
 */
 public static list<map<string, object>> readexcelbyrc(string filename, int statrrow, int endrow, boolean existtop) {
 //判断输入的开始值是否少于等于结束值
 if (statrrow > endrow && endrow != -1) {
  logger.warn("输入的开始行值比结束行值大，请重新输入正确的行数");
  list<map<string, object>> error = null;
  return error;
 }
 //声明返回的结果集
 list<map<string, object>> result = new arraylist<>();
 //声明一个工作薄
 workbook workbook = null;
 //声明一个文件输入流
 fileinputstream inputstream = null;
 try {
  // 获取excel后缀名，判断文件类型
  string filetype = filename.substring(filename.lastindexof(".") + 1);
  // 获取excel文件
  file excelfile = new file(filename);
  if (!excelfile.exists()) {
  logger.warn("指定的excel文件不存在！");
  return null;
  }
  // 获取excel工作簿
  inputstream = new fileinputstream(excelfile);
  workbook = getworkbook(inputstream, filetype);
  //处理excel内容
  result = handledata(workbook, statrrow, endrow, existtop);
 } catch (exception e) {
  logger.warn("解析excel失败，文件名：" + filename + " 错误信息：" + e.getmessage());
 } finally {
  try {
  if (null != workbook) {
   workbook.close();
  }
  if (null != inputstream) {
   inputstream.close();
  }
  } catch (exception e) {
  logger.warn("关闭数据流出错！错误信息：" + e.getmessage());
  return null;
  }
 }
 return result;
 }


/**==============================================================================================================================**/

 /**
 * 方法二
 * 根据给定的实体类中赋值的注解值读取excel
 * filename:excel文件路径
 * statrrow：读取的开始行数（默认填0）
 * endrow：读取的结束行数（填-1为全部）
 * class<t>：传过来的实体类类型
 * 返回一个list<t>:t为实体类
 */
 public static list<object> readexcelbypojo(string filename, int statrrow, int endrow, class t) throws invocationtargetexception, introspectionexception, instantiationexception, illegalaccessexception, nosuchfieldexception {
 //判断输入的开始值是否少于等于结束值
 if (statrrow > endrow && endrow != -1) {
  logger.warn("输入的开始行值比结束行值大，请重新输入正确的行数");
  list<object> error = null;
  return error;
 }
 //声明返回的结果集
 list<object> result = new arraylist<>();
 //声明一个工作薄
 workbook workbook = null;
 //声明一个文件输入流
 fileinputstream inputstream = null;
 try {
  // 获取excel后缀名，判断文件类型
  string filetype = filename.substring(filename.lastindexof(".") + 1);
  // 获取excel文件
  file excelfile = new file(filename);
  if (!excelfile.exists()) {
  logger.warn("指定的excel文件不存在！");
  return null;
  }
  // 获取excel工作簿
  inputstream = new fileinputstream(excelfile);
  workbook = getworkbook(inputstream, filetype);
  //处理excel内容
  result = handledatapojo(workbook, statrrow, endrow, t);
 } catch (exception e) {
  logger.warn("解析excel失败，文件名：" + filename + " 错误信息：" + e.getmessage());
 } finally {
  try {
  if (null != workbook) {
   workbook.close();
  }
  if (null != inputstream) {
   inputstream.close();
  }
  } catch (exception e) {
  logger.warn("关闭数据流出错！错误信息：" + e.getmessage());
  return null;
  }
 }
 return result;
 }


 /**
 * 处理excel内容转为list<t>输出
 * workbook：已连接的工作薄
 * statrrow：读取的开始行数（默认填0，0开始,传过来是excel的行数值默认从1开始，这里已处理减1）
 * endrow：读取的结束行数（填-1为全部）
 * class<t>：所映射的实体类
 */
 private static <t> list<object> handledatapojo(workbook workbook, int statrrow, int endrow, class<?> t) throws introspectionexception, nosuchfieldexception, illegalaccessexception, instantiationexception, invocationtargetexception, classnotfoundexception {
 //声明返回的结果集
 list<object> result = new arraylist<object>();
 //解析sheet（sheet是excel脚页）
 for (int sheetnum = 0; sheetnum < workbook.getnumberofsheets(); sheetnum++) {
  sheet sheet = workbook.getsheetat(sheetnum);
  // 校验sheet是否合法
  if (sheet == null) {
  continue;
  }
  //获取头部数据
  //声明头部数据数列对象
  arraylist<string> top = new arraylist<>();
  //获取excel第一行数据
  int firstrownum = sheet.getfirstrownum();
  row firstrow = sheet.getrow(firstrownum);
  if (null == firstrow) {
  logger.warn("解析excel失败，在第一行没有读取到任何数据！");
  return null;
  }
  for (int i = 0; i < firstrow.getlastcellnum(); i++) {
  top.add(convertcellvaluetostring(firstrow.getcell(i)));
  }
  //获取实体类的成原变量
  map<string, object> pojofields = getpojofieldandvalue(t);
  //判断所需要的数据列
  map<string, object> exceltopojo = new hashmap<>();
  for (int i = 0; i < top.size(); i++) {
  if (pojofields.get(top.get(i)) != null && !"".equals(pojofields.get(top.get(i)))) {
   exceltopojo.put(string.valueof(i), pojofields.get(top.get(i)));
  }
  }
  /*处理excel数据内容*/
  int endrownum;
  //获取结束行数
  if (endrow == -1) {
  endrownum = sheet.getphysicalnumberofrows();
  } else {
  endrownum = endrow <= sheet.getphysicalnumberofrows() ? endrow : sheet.getphysicalnumberofrows();
  }
  list<map<string, object>> maplist = new arraylist<>();
  //遍历行数
  for (int i = statrrow - 1; i < endrownum; i++) {
  row row = sheet.getrow(i);
  if (null == row) {
   continue;
  }
  //获取需要的列数据
  t texcel = (t) t.newinstance();
  for (map.entry<string, object> map : exceltopojo.entryset()) {
   //获取exceld对应列的数据
   string celldata = convertcellvaluetostring(row.getcell(integer.parseint(map.getkey())));
   //使用发射
   //获取实体类t中指定成员变量的对象
   propertydescriptor pd = new propertydescriptor((string) map.getvalue(), texcel.getclass());
   //获取成员变量的set方法
   method method = pd.getwritemethod();
   //判断成员变量的类型
   field field = texcel.getclass().getdeclaredfield((string) map.getvalue());
   string object = field.getgenerictype().gettypename();
   if (object.endswith("string")) {
   //执行set方法
   method.invoke(texcel, celldata);
   }
   if (object.endswith("double")) {
   double middata = double.valueof(celldata);
   //执行set方法
   method.invoke(texcel, middata);
   }
   if (object.endswith("float")) {
   float middata = float.valueof(celldata);
   //执行set方法
   method.invoke(texcel, middata);
   }
   if (object.endswith("integer")) {
   integer middata = integer.parseint(celldata);
   //执行set方法
   method.invoke(texcel, middata);
   }
  }
  result.add(texcel);
  }
 }
 return result;
 }

 /**
 * 获取对应的实体类成员
 * */
 private static map<string, object> getpojofieldandvalue(class t) {
 //声明返回结果集
 map<string, object> result = new hashmap<>();
 field[] fields = t.getdeclaredfields();//获取属性名
 if (fields != null) {
  for (field field : fields) {
  excelrescoure rescoure = field.getannotation(excelrescoure.class);
  if (rescoure.value() != null && !"".equals(rescoure.value())) {
   result.put(rescoure.value(), field.getname());
  }
  }
 } else {
  logger.warn("实体类：" + t + "不存在成员变量");
  return null;
 }
 return result;
 }
}

5.测试类

package com.cly.utils.excel;

import java.util.*;


/**
 * @author : cly
 * @classname : readtest
 * @date : 2020/7/9 16:31
 **/
public class readtest {
public static void main(string[] args) throws exception {
 /** 方法一
 * filename:excel文件路径
 * statrrow：读取的开始行数（默认填0）
 * endrow：读取的结束行数（填-1为全部）
 * existtop:是否存在头部（如存在则读取数据时会把头部拼接到对应数据作为key，若无则key为当前列数）
 */
 list<map<string,object>> result =excelread.readexcelbyrc("d:.xls",2,10,false);
 system.out.println(result.size());
 system.out.println(result);

 /**
 * 方法二
 * readexcelbypojo(string filename, int statrrow, int endrow, class t)
 * filename:excel文件路径
 * statrrow：读取的开始行数（默认填0）
 * endrow：读取的结束行数（填-1为全部）
 * class<t>：传过来的实体类类型
 */
 list<object> result2 = excelread.readexcelbypojo("d:.xls",2,10,excelpojo.class);
 system.out.println(result2.size());
 system.out.println(result2);
 }
}
 

6.运行结果和说明

exce表格数据

方法一的运行结果

1.ture:key为列名

2.false:key为第几列列数

方法二的运行结果

实体类的所有成员变量一定要加上自定义注释@excelrescoure，不然会报错

还有很多不足的地方，请多多指点，希望能给你带来帮助。

springboot实现内存数据导出成excel在另一篇文章 文章地址：

总结

到此这篇关于springboot实现excel读取的文章就介绍到这了,更多相关springboot实现excel读取内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！