Java POI实现Excel导入-通用组件

谁借莪１个温暖的怀抱￠ 2022-03-28 04:09 353阅读 0赞

在工作中，会经常大量使用到Excel导入，如果每个开发人员都自己实现一套Excel导入，带来的问题是研发效率降低，项目中存在大量重复的代码，这时就有必要将Excel导入写成通用组件，开发人员使用该组件，便可轻松实现导入功能
设计思路：
1.将Excel导入设计成模板形式，导入前需要配置此模板
2.通过反射的形式调用对应VO的属性的set方法，给属性赋值
3.返回解析后的结果集

Excel导入模板设计
在src/main/resource/excel/目录下，创建mairuan.import.template.xml文件，将要导入的Excel，配置成模板的形式，内容如下

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <import>
  3.     <!-- type类型:Byte,Short,Integer,Long,Float,Double,char,String,缺省为String -->
  4.     <sheet id="importRole" startRow="1" class="com.mairuan.base.system.model.RoleVO">
  5.         <column name="RoleCode"  type="String"></column>
  6.         <column name="RoleName"  type="String"></column>
  7.         <column name="RoleDesc"  type="String"></column>
  8.         <column name="RoleState" type="String"></column>
  9.     </sheet>
  10. </import>

说明：
1.一个sheet标签代表一个sheet页
2.startRow代表从哪行开始解析
3.class代表使用哪个对象来承载Excel中的值
4.name 对应class对应中的属性名，首字母必须大写
5.type表示该字段的数据类型，解析Excel时，得到单元格中的数据类型，和我们预想的不一至，会影响通过反射调用set方法，因此使用该字段进行类型转换

创建ImportExcelUtil工具类
1. 在工具类中增加解析mairuan.import.template.xml模板的方法

  1. @SuppressWarnings("unchecked")
  2. private static Element readXML(String sheetId) throws DocumentException, FileNotFoundException {
  3.     File file = ResourceUtils.getFile("classpath:/excel/mairuan.import.template.xml");
  4.     SAXReader reader = new SAXReader();
  5.     Document document = reader.read(file);
  6.     Element root = document.getRootElement();
  7.     Iterator<Element> iterator = root.elementIterator();
  8.     Element element = null;
  9.     while (iterator.hasNext()) {
  10.         element = iterator.next();
  11.         if (sheetId.equals(element.attributeValue("id"))) {
  12.             break;
  13.         }
  14.     }
  15.     return element;
  16. }

根据传入的sheetID，查找对应的标签，如果找到，就反回

2. 在工具类中增加根据type值获得参数类型的方法

  1. private static Class<?> getParameterType(String parameterType) {
  2.         switch (parameterType) {
  3.         case "Byte":
  4.             return Byte.class;
  5.         case "Short":
  6.             return Short.class;
  7.         case "Integer":
  8.             return Integer.class;
  9.         case "Long":
  10.             return Long.class;
  11.         case "Float":
  12.             return Float.class;
  13.         case "Double":
  14.             return Double.class;
  15.         case "char":
  16.             return char.class;
  17.         case "String":
  18.             return String.class;
  19.         case "Date":
  20.             return Date.class;
  21.         default:
  22.             return String.class;
  23.         }
  24.     }

3. 在工具类中增加解析Excel的主方法

  1. @SuppressWarnings("unchecked")
  2. public static List parseExcel(String sheetId, InputStream input) throws Exception {
  4.     // 根据sheetId解析xml，获取Excel模板
  5.     Element element = readXML(sheetId);
  6.     String clazzString = element.attributeValue("class");
  8.     // 从哪行开始解析
  9.     int start = Integer.valueOf(element.attributeValue("startRow"));
  11.     // 反射创建对象实例
  12.     Class<? extends Object> clazz = Class.forName(clazzString);
  14.     List<Element> columns = element.elements();
  16.     Object instance = null;
  17.     // 结果集
  18.     List resultList = new ArrayList();
  19.     // 要调用的方法
  20.     Method method = null;
  21.     // 调用Set方法要传递的参数
  22.     Class<?>[] args = null;
  24.     Cell cell = null;
  25.     XSSFWorkbook wb = null;
  26.     try 
  27.     {
  28.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  29.         // wb = new XSSFWorkbook(file);
  30.         wb = new XSSFWorkbook(input);
  31.         // 获取第一个Sheet页
  32.         XSSFSheet sheet = wb.getSheetAt(0);
  33.         for (int i = start; i <= sheet.getLastRowNum(); i++) {
  34.             Row row = sheet.getRow(i);
  35.             if(row == null)
  36.             {
  37.                 continue;
  38.             }
  39.             instance = clazz.newInstance();
  41.             StringBuffer buf = new StringBuffer();
  42.             for (int j = 0; j < row.getLastCellNum(); j++) {
  43.                 cell = row.getCell(j);
  44.                 if (cell == null) {
  45.                     continue;
  46.                 }
  47.                 args = new Class[1];
  48.                 args[0] = getParameterType(columns.get(j).attributeValue("type"));
  49.                 Object value = getCellValue(cell,args[0],dateFormat);
  51.                 //累计字符串内容
  52.                 buf.append(getStringValue(value));
  54.                 //Date情况转成String,其他类型保持原样
  55.                 args[0] = Date.class.equals(args[0]) ? String.class : args[0];
  57.                 method = clazz.getDeclaredMethod("set" + columns.get(j).attributeValue("name"), args);
  58.                 method.invoke(instance, value);
  59.             }
  61.             //整行为空时丢弃该行数据
  62.             if ("".equals(buf.toString().trim()))
  63.             {
  64.                 continue;
  65.             }
  66.             //加到集合中
  67.             resultList.add(instance);
  68.         }
  69.     } catch (Exception e) {
  70.         throw e;
  71.     } finally {
  72.         if (wb != null) {
  73.             wb.close();
  74.         }
  75.     }
  76.     return resultList;
  77. }

说明：
1.外层for循环是读取Excel中的行，内层循环是解析每一行数据到对应的VO属性中
2.通过反射的方式给VO属性赋值
3.根据getCellValue方法获得不同类型的数据值，如果类型不对，反射执行赋值会失败
4.如果整行为空，则丢弃这行记录
5.最后将结果集resultList返回

最后完整的ImportExcelUtil工具类如下

  1. package com.mairuan.base.utils;
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.InputStream;
  6. import java.lang.reflect.Method;
  7. import java.text.DecimalFormat;
  8. import java.text.SimpleDateFormat;
  9. import java.util.ArrayList;
  10. import java.util.Date;
  11. import java.util.Iterator;
  12. import java.util.List;
  14. import org.apache.poi.ss.usermodel.Cell;
  15. import org.apache.poi.ss.usermodel.Row;
  16. import org.apache.poi.xssf.usermodel.XSSFSheet;
  17. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
  18. import org.dom4j.Document;
  19. import org.dom4j.DocumentException;
  20. import org.dom4j.Element;
  21. import org.dom4j.io.SAXReader;
  22. import org.springframework.util.ResourceUtils;
  24. public class ImportExcelUtil {
  26.     @SuppressWarnings("unchecked")
  27.     public static List parseExcel(String sheetId, InputStream input) throws Exception {
  29.         // 根据sheetId解析xml，获取Excel模板
  30.         Element element = readXML(sheetId);
  31.         String clazzString = element.attributeValue("class");
  33.         // 从哪行开始解析
  34.         int start = Integer.valueOf(element.attributeValue("startRow"));
  36.         // 反射创建对象实例
  37.         Class<? extends Object> clazz = Class.forName(clazzString);
  39.         List<Element> columns = element.elements();
  41.         Object instance = null;
  42.         // 结果集
  43.         List resultList = new ArrayList();
  44.         // 要调用的方法
  45.         Method method = null;
  46.         // 调用Set方法要传递的参数
  47.         Class<?>[] args = null;
  49.         Cell cell = null;
  50.         XSSFWorkbook wb = null;
  51.         try 
  52.         {
  53.             SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  55.             // wb = new XSSFWorkbook(file);
  56.             wb = new XSSFWorkbook(input);
  57.             // 获取第一个Sheet页
  58.             XSSFSheet sheet = wb.getSheetAt(0);
  59.             for (int i = start; i <= sheet.getLastRowNum(); i++) {
  60.                 Row row = sheet.getRow(i);
  61.                 if(row == null)
  62.                 {
  63.                     continue;
  64.                 }
  65.                 instance = clazz.newInstance();
  67.                 StringBuffer buf = new StringBuffer();
  68.                 for (int j = 0; j < row.getLastCellNum(); j++) {
  69.                     cell = row.getCell(j);
  70.                     if (cell == null) {
  71.                         continue;
  72.                     }
  73.                     args = new Class[1];
  74.                     args[0] = getParameterType(columns.get(j).attributeValue("type"));
  75.                     Object value = getCellValue(cell,args[0],dateFormat);
  77.                     //累计字符串内容
  78.                     buf.append(getStringValue(value));
  80.                     //Date情况转成String,其他类型保持原样
  81.                     args[0] = Date.class.equals(args[0]) ? String.class : args[0];
  83.                     method = clazz.getDeclaredMethod("set" + columns.get(j).attributeValue("name"), args);
  84.                     method.invoke(instance, value);
  85.                 }
  87.                 //整行为空时丢弃该行数据
  88.                 if ("".equals(buf.toString().trim()))
  89.                 {
  90.                     continue;
  91.                 }
  92.                 //加到集合中
  93.                 resultList.add(instance);
  94.             }
  95.         } catch (Exception e) {
  96.             throw e;
  97.         } finally {
  98.             if (wb != null) {
  99.                 wb.close();
  100.             }
  101.         }
  102.         return resultList;
  103.     }
  105.     public static boolean checkFileType(String filename) {
  106.         if ((filename == null) || (filename.length() == 0)) {
  107.             return false;
  108.         }
  110.         String type = "";
  111.         int dot = filename.lastIndexOf('.');
  112.         if ((dot > -1) && (dot < (filename.length() - 1))) {
  113.             type = filename.substring(dot + 1);
  114.         }
  115.         if (!"xlsx".equalsIgnoreCase(type)) {
  116.             return false;
  117.         }
  118.         return true;
  119.     }
  121.     @SuppressWarnings("unchecked")
  122.     private static Element readXML(String sheetId) throws DocumentException, FileNotFoundException {
  123.         File file = ResourceUtils.getFile("classpath:/excel/mcc.base.import.xml");
  124.         SAXReader reader = new SAXReader();
  125.         Document document = reader.read(file);
  126.         Element root = document.getRootElement();
  127.         Iterator<Element> iterator = root.elementIterator();
  128.         Element element = null;
  129.         while (iterator.hasNext()) {
  130.             element = iterator.next();
  131.             if (sheetId.equals(element.attributeValue("id"))) {
  132.                 break;
  133.             }
  134.         }
  135.         return element;
  136.     }
  138.     private static Object getCellValue(Cell cell,Class<? extends Object> clazz,SimpleDateFormat dateFormat) {
  139.         Object obj = null;
  140.         switch (cell.getCellType()) {
  141.         case Cell.CELL_TYPE_BOOLEAN:
  142.             obj = cell.getBooleanCellValue();
  143.             break;
  144.         case Cell.CELL_TYPE_ERROR:
  145.             obj = cell.getErrorCellValue();
  146.             break;
  147.         case Cell.CELL_TYPE_NUMERIC:
  148.             //用户自定义类型检测
  149.             if(String.class.equals(clazz))
  150.             {
  151.                 DecimalFormat df = new DecimalFormat("#.#########"); // 数字格式，防止长数字成为科学计数
  152.                 obj = df.format(cell.getNumericCellValue());
  153.             }else if(Date.class.equals(clazz))
  154.             {
  155.                 obj = dateFormat.format(cell.getDateCellValue());
  156.             }else if(Double.class.equals(clazz)) {
  157.                 obj = cell.getNumericCellValue();
  158.             }else if(Integer.class.equals(clazz)) {
  159.                 DecimalFormat df = new DecimalFormat("#.#########"); // 数字格式，防止长数字成为科学计数
  160.                 String val = df.format(cell.getNumericCellValue());
  161.                 obj = Integer.parseInt(val);
  162.             }
  163.             break;
  164.         case Cell.CELL_TYPE_STRING:
  165.             String cellValue = cell.getStringCellValue();
  167.             if (Double.class.equals(clazz)) {
  168.                 Double d = Double.valueOf(cellValue);
  169.                 obj = d;
  170.             }else if(Integer.class.equals(clazz)) {
  171.                 obj = Integer.parseInt(cellValue);
  172.             }else {
  173.                 obj=cellValue;
  174.             }
  175.             break;
  176.         default:
  177.             break;
  178.         }
  180.         return obj;
  181.     }
  182.     /**
  183.      * 获取参数类型，默认为String
  184.      * 
  185.      * @param parameterType
  186.      * @return
  187.      */
  188.     private static Class<?> getParameterType(String parameterType) {
  189.         switch (parameterType) {
  190.         case "Byte":
  191.             return Byte.class;
  192.         case "Short":
  193.             return Short.class;
  194.         case "Integer":
  195.             return Integer.class;
  196.         case "Long":
  197.             return Long.class;
  198.         case "Float":
  199.             return Float.class;
  200.         case "Double":
  201.             return Double.class;
  202.         case "char":
  203.             return char.class;
  204.         case "String":
  205.             return String.class;
  206.         case "Date":
  207.             return Date.class;
  208.         default:
  209.             return String.class;
  210.         }
  211.     }
  213.     /**
  214.      * 获取字符串内容
  215.      * @param obj
  216.      * @return
  217.      */
  218.     private static String getStringValue(Object obj)
  219.     {
  220.         if (obj != null)
  221.         {
  222.             return String.valueOf(obj);
  223.         }
  224.         return "";
  225.     }
  226. }

Spring MVC控制层调用导入工具类解析Excel

  1. @RequestMapping(value = "/importCoreList", method = RequestMethod.POST)
  2. @ResponseBody
  3. public ResponseVO<List<RoleVO>> importExcel(HttpServletRequest request, @RequestParam("file") MultipartFile file)
  4.         throws Exception {
  6.     ResponseVO<List<RoleVO>> response = new ResponseVO<List<RoleVO>>();
  7.     try {
  8.         if (file.isEmpty()) {
  9.             response.setStatus(ResponseVO.failCode);
  10.             response.setMessage("文件为空");
  11.             return response;
  12.         }
  13.         if (!ImportExcelUtil.checkFileType(file.getOriginalFilename())) {
  14.             response.setStatus(ResponseVO.failCode);
  15.             response.setMessage("只支持2007版以上的Excel导入");
  16.             return response;
  17.         }
  18.         String sheetId = "importRole";
  19.         List<RoleVO> result = (List<RoleVO>) ImportExcelUtil.parseExcel(sheetId, file.getInputStream());
  20.         response.setData(result );
  21.     } catch (Exception e) {
  22.         logger.error("Import Excel fail,The message is:", e);
  23.         response.setStatus(ResponseVO.failCode);
  24.     }
  25.     return response;
  26. }

开发人员只需要通过List result = (List) ImportExcelUtil.parseExcel(sheetId, file.getInputStream());就可以将Excel中的值转换成想要的VO对应，进行后面的数据操作

发表评论

表情：
评论列表 （有 0 条评论，353人围观）

还没有评论，来说两句吧...

相关阅读