Spring boot poi 导入，适应根据表头名导入，合并单元格导入

最新推荐文章于 2024-08-19 16:30:20 发布
最新推荐文章于 2024-08-19 16:30:20 发布
阅读量430 收藏 2
点赞数 1
分类专栏： excel导入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28915045/article/details/118109049
版权

Springboot Apache POI Excel导入 注解 数据验证
关键词由CSDN通过智能技术生成

Spring boot poi 导入（根据表头名导入，合并单元格导入）

添加依赖

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

代码实现

导入注解类 ExcelImportAnnotation

/**
 * @author hbj
 * @Date 2021/5/17 15:09
 * @Description Excel导入注解
 * @Modified By
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelImportAnnotation {
    /**
     * 表头中文
     *
     * @return
     */
    String titleName() default "";

    /**
     * 是否允许空值 ，默认不允许
     *
     * @return
     */
    boolean required() default false;

    /**
     * 时间格式
     *
     * @return
     */
    String format() default "yyyy-MM-dd";

    /**
     * 多元素判断，每个元素用，隔开，如:是,否，对应的values值为1,0
     *
     * @return
     */
    String judge_items() default "";
    /**
     * 多元素判断值，每个元素用，隔开, 如:1,0
     *
     * @return
     */
    String judge_values() default  "";

    /**
     * 默认值
     *
     * @return
     */
    String judge_defaultValue() default "";

    /**
     * 行号
     *
     * @return
     */
    boolean isRow() default false;
}

导入映射类

/**
 * @author hbj
 * @Date 2021/5/28 10:21
 * @Description
 * @Modified By
 */
@Data
public class ImportDto {
    @ApiModelProperty(value = "Excel行号")
    @ExcelImportAnnotation(isRow = true)
    private Integer row;

    @ApiModelProperty(value = "班级")
    @ExcelImportAnnotation(titleName = "班级",required = true)
    private String grade;

    @ApiModelProperty(value = "学生姓名")
    @ExcelImportAnnotation(titleName = "学生姓名",required = true)
    private Date studentName;

    @ApiModelProperty(value = "语文分数")
    @ExcelImportAnnotation(titleName = "语文分数",required = true)
    private BigDecimal chineseScore;

	@ApiModelProperty(value = "数学分数")
    @ExcelImportAnnotation(titleName = "数学分数",required = true)
    private BigDecimal mathScore;

    @ApiModelProperty(value = "英语分数")
    @ExcelImportAnnotation(titleName = "英语分数",required = true)
    private BigDecimal englishScore;
    
}

导入异常处理类

/**
 * @author hbj
 * @Date 2021/6/22 15:29
 * @Description
 * @Modified By
 */
public class ImportException extends RuntimeException{
    public ImportException(String msg) {
        super(msg);
    }
}

导入工具类

/**
 * @author hbj
 * @Date 2021/5/17 15:38
 * @Description
 * @Modified By
 */
public class ExcelUtil {

    /**
     * xls 后缀
     */
    public static final String XLS = "xls";
    /**
     * xlsx 后缀
     */
    public static final String XLS_X = "xlsx";

    /**
     * 传入文本对象输出list集合（导入），只导入第一页（sheet1）
     *
     * @param file  流文件
     * @param clazz 要转义成的类对象
     * @return
     */
    public static <T> List<T> importExcelSheet1(MultipartFile file, Class<T> clazz) throws Exception {
        // 检查文件
        Workbook workbook = getWorkBook(file);
        List<T> list = new ArrayList<T>();
        checkFile(file);
        // 获得HSSFWorkbook工作薄对象
        if (workbook != null) {
            // 获得当前sheet工作表
            Sheet sheet = workbook.getSheetAt(0);
            //获取表头
            Map<String,Integer> titleMap=getExcelSheetTitle(sheet);
            //获取对应表头对应的实体字段集合
            Map<Integer,Field> fieldMap= getFieldMap(clazz,titleMap);
            //获取所有合并的单元格
            Map<String,Cell> combineCellMap=getCombineCell(sheet);

            // 获取当前sheet工作表的列总数
            int firstLine = sheet.getRow(0).getPhysicalNumberOfCells();
            // 获得当前sheet的开始行
            int firstRowNum = sheet.getFirstRowNum()+1;//不用读取表头
            // 获得当前sheet的结束行
            int lastRowNum = sheet.getLastRowNum();
            // 循环所有行
            for (int rowNum = firstRowNum; rowNum <= lastRowNum; rowNum++) {
                // 获得当前行
                Row row = sheet.getRow(rowNum);
                if (row == null) {
                    continue;
                }
                Object obj = clazz.newInstance();
                //循环所有列得到单元格
                for (int cellNum = 0; cellNum < firstLine; cellNum++) {
                    // 取出对应对象属性
                    Field field=fieldMap.get(cellNum);
                    if(field==null){
                        continue;
                    }
                    Cell cell = row.getCell(cellNum);
                    //是否合并单元格
                    if(!combineCellMap.isEmpty()&&combineCellMap.containsKey(rowNum+"#"+cellNum)){
                        cell=combineCellMap.get(rowNum+"#"+cellNum);
                    }
                    //录入行号
                    Field mfield=fieldMap.get(-1);//行号
                    if(mfield!=null){
                        if (!mfield.isAccessible()) {
                            mfield.setAccessible(true);
                        }
                        if(mfield.get(obj)==null&&cell!=null){
                            mfield.set(obj,cell.getRowIndex());
                        }
                    }
                    if(cell!=null){
                        Object value=getCellValue(cell);
                        // 根绝类型 实体类赋值
                        createBean(field, obj, value,rowNum);
                    }
                }
                if (rowNum == 0) {
                    // 表头不做记录
                    continue;
                }
                if(checkObjFieldIsNotNull(obj)) {
                    //必填校验
                    checkRequired(obj,rowNum);
                    list.add((T) obj);
                }else{//有一行是空的就默认结束行
                    return list;
                }
            }
        }
        return list;
    }

    private static void checkRequired(Object obj,int rowNum ) throws IllegalAccessException {

        //获取对象总数量
        Field[] fields = obj.getClass().getDeclaredFields();
        if (fields == null || fields.length == 0) {
            return;
        }
        StringJoiner joiner=new StringJoiner(",");
        for (Field field : fields) {
            if(!field.isAccessible()){
                field.setAccessible(true);
            }
            ExcelImportAnnotation annotation=field.getAnnotation(ExcelImportAnnotation.class);
            Object obj2=field.get(obj);
            if(annotation!=null && annotation.required() && obj2==null){//必填
                joiner.add(annotation.titleName());
            }else if(obj2!=null&&annotation!=null&& StringUtils.isNotBlank(annotation.judge_items())){
                List<String> items=Arrays.asList(annotation.judge_items().split(","));
                List<String> values=Arrays.asList(annotation.judge_values().split(","));
                int index=items.indexOf(obj2.toString());
                if(index>-1&&values.size()>index){
                    field.set(obj,values.get(index));
                }
            }
        }
        if(joiner.length()>0){
            rowNum++;
            throw new ImportException("第"+rowNum+"行【"+joiner+"】不能为空");
        }
    }

    /**
     * 获取表头
     * @param sheet
     * @return
     */
    private static Map<String, Integer> getExcelSheetTitle(Sheet sheet) {
        Map<String, Integer> titleMap=new HashMap<>();
        Row row = sheet.getRow(0);
        // 获取当前sheet工作表的列总数
        int allLine = row.getPhysicalNumberOfCells();
        for (int cellNum = 0; cellNum < allLine; cellNum++) {
            Cell cell = row.getCell(cellNum);
            if(cell!=null&&StringUtils.isNotBlank(cell.getStringCellValue())){
                titleMap.put(cell.getStringCellValue(),cellNum);
            }
        }
        return titleMap;
    }

    /**
     * 创建工作簿
     * @param file
     * @return
     */
    private static Workbook getWorkBook(MultipartFile file) {
        // 获得文件名
        String fileName = file.getOriginalFilename();
        // 创建Workbook工作薄对象，表示整个excel
        Workbook workbook = null;
        // 获取excel文件的io流
        InputStream is = null;
        try {
            is = file.getInputStream();
            // 根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象
            if (fileName.endsWith(XLS)) {
                // 2003
                workbook = new HSSFWorkbook(is);
            } else if (fileName.endsWith(XLS_X)) {
                // 2007
                workbook = new XSSFWorkbook(is);
            }
        } catch (IOException e) {
            throw new ImportException("excel 转换 HSSFWorkbook 异常！");
        }
        return workbook;
    }

    /**
     * 检查文件
     *
     * @param file
     * @throws IOException
     */
    private static void checkFile(MultipartFile file) {
        // 判断文件是否存在
        if (null == file) {
            throw new ImportException("文件不存在");
        }
        // 获得文件名
        String fileName = file.getOriginalFilename();
        // 判断文件是否是excel文件
        if (!fileName.endsWith(XLS) && !fileName.endsWith(XLS_X)) {
            throw new ImportException( fileName + "不是excel文件");
        }
    }

    /**
     * 获取实体属性集合
     *
     * @param clazz 对象
     * @param titleMap  表头数组key->表头名，value->列数
     * @return
     */
    private static Map<Integer,Field> getFieldMap(Class clazz,Map<String,Integer> titleMap) {
        Map<Integer,Field> fieldMap=new HashMap<>();
        //获取对象总数量
        Field[] fields = clazz.getDeclaredFields();
        if (fields == null || fields.length == 0) {
            return fieldMap;
        }
        Class<ExcelImportAnnotation> cls=ExcelImportAnnotation.class;
        for (Field field : fields) {
            if(field.isAnnotationPresent(cls)){
                if (StringUtils.isNotBlank(field.getAnnotation(cls).titleName())) {
                    String key=field.getAnnotation(cls).titleName();
                    if(titleMap.get(key)!=null){
                        fieldMap.put(titleMap.get(key),field);
                    }
                }else if(field.getAnnotation(cls).isRow()){//行号
                    fieldMap.put(-1,field);
                }
            }

        }
        return fieldMap;
    }

    /**
     * 根据实体类型 赋值数据
     *
     * @param field
     * @param newInstance
     * @param value
     * @param <T>
     */
    private static <T> void createBean(Field field, T newInstance, Object value,int rowNum) {
        if(field==null){
            return;
        }
        if (!field.isAccessible()) {
            field.setAccessible(true);
        }
        try {
            if (value == null|| StringUtils.isBlank(String.valueOf(value))) {
                field.set(newInstance, null);
            } else if (Long.class.equals(field.getType())) {
                field.set(newInstance, Long.valueOf(String.valueOf(value)));
            } else if (String.class.equals(field.getType())) {
                field.set(newInstance, String.valueOf(value));
            } else if (Integer.class.equals(field.getType())) {
                field.set(newInstance, Integer.valueOf(String.valueOf(value)));
            } else if (Date.class.equals(field.getType())) {
                SimpleDateFormat sdf = new SimpleDateFormat(field.getAnnotation(ExcelImportAnnotation.class).format());
                if (value instanceof Date)   {
                    field.set(newInstance, sdf.parse(sdf.format(value)));
                } else {
                    field.set(newInstance, sdf.parse(value.toString()));
                }
            } else if (Boolean.class.equals(field.getType())) {
                field.set(newInstance, (Boolean) value);
            } else if (Double.class.equals(field.getType())) {
                field.set(newInstance, Double.valueOf(String.valueOf(value)));
            } else if (Float.class.equals(field.getType())) {
                field.set(newInstance, Float.valueOf(String.valueOf(value)));
            } else if (BigDecimal.class.equals(field.getType())) {
                field.set(newInstance, new BigDecimal(String.valueOf(value)));
            } else {
                field.set(newInstance, value);
            }
        } catch (Exception e) {
            rowNum++;
            throw new ImportException("【excel导入】excel实体转换异常！第"+rowNum+"行字段【"
                    + field.getAnnotation(ExcelImportAnnotation.class).titleName() + "】，值（" + value + "）");
        }
    }

    /**
     * 列转化值
     *
     * @param cell 列值
     * @throws IOException
     */
    private static Object getCellValue(Cell cell) {
        if (cell == null) {
            return null;
        }
        Object cellValue;
        // 把数字当成String来读，避免出现1读成1.0的情况
        // 判断数据的类型
        switch (cell.getCellTypeEnum()) {
            case NUMERIC:

                if (DateUtil.isValidExcelDate(cell.getNumericCellValue())) {
                    CellStyle style = cell.getCellStyle();
                    if (style == null) {
                        return false;
                    }
                    int formatIndex = style.getDataFormat();
                    String formatString = style.getDataFormatString();
                    boolean isDate = DateUtil.isADateFormat(formatIndex, formatString);
                    if (isDate) {          Date date = cell.getDateCellValue();
                        return date;
                    }
                }
                if ((long) cell.getNumericCellValue() != cell.getNumericCellValue()) {
                    // double 类型
                    cellValue = new BigDecimal(String.valueOf(cell.getNumericCellValue()));
                } else {
                    cellValue = (long)cell.getNumericCellValue();
                }
                break;
            // 字符串
            case STRING:
                cellValue = String.valueOf(cell.getStringCellValue());
                break;

            // Boolean
            case BOOLEAN:
                cellValue = String.valueOf(cell.getBooleanCellValue());
                break;
            // 公式
            case FORMULA:
                cellValue = String.valueOf(cell.getCellFormula());
                break;
            // 空值
            case BLANK:
                cellValue = null;
                break;
            // 故障
            case ERROR:
                cellValue = "非法字符";
                break;
            default:
                cellValue = "未知类型";
                break;
        }
        return cellValue;
    }

    private static boolean checkObjFieldIsNotNull(Object obj){
        try {
            Class<ExcelImportAnnotation> cls=ExcelImportAnnotation.class;
            for (Field f : obj.getClass().getDeclaredFields()) {
                if(f.isAnnotationPresent(cls)&&f.getAnnotation(cls).isRow()){
                   continue;
                }
                f.setAccessible(true);
                if (f.get(obj) != null) {
                    return true;
                }
            }
        }catch (IllegalAccessException e){

        }
        return false;
    }

    /**
     * 获取sheet中合并的单元格个数，并返回单元格list
     * @param sheet
     * @return Map<String,Object> key->row+"#"+cell
     */
    public static Map<String,Cell> getCombineCell(Sheet sheet)
    {
        Map<String,Cell> map = new HashMap<>();
        //获得一个 sheet 中合并单元格的数量
        int sheetmergerCount = sheet.getNumMergedRegions();
        //遍历所有的合并单元格
        for(int i = 0; i<sheetmergerCount;i++)
        {
            //获得合并单元格保存进list中
            CellRangeAddress ca = sheet.getMergedRegion(i);
            int firstColumn = ca.getFirstColumn();
            int lastColumn = ca.getLastColumn();
            int firstRow = ca.getFirstRow();
            int lastRow = ca.getLastRow();
            for(int r=firstRow;r<=lastRow;r++){
                for(int c=firstColumn;c<=lastColumn;c++){
                    map.put(r+"#"+c,sheet.getRow(firstRow).getCell(firstColumn));
                }
            }
        }
        return map;
    }

Controller

/**
 * @author bojin.he
 * @Date 2021/6/22 15:47
 * @Description
 * @Modified By
 */
@RestController
@RequestMapping("/excel")
public class ExcelCtrl {

    @PostMapping("/excelImport")
    public List<ImportDto> excelImport(@RequestParam("file") MultipartFile file) throws Exception {
        List<ImportDto> importDtos= ExcelUtil.importExcelSheet1(file,ImportDto.class);
        return importDtos;
    }
}

excel内容

在这里插入图片描述

hbj89
关注
专栏目录
java复合表头_Java中使用 poi 导出复合表头（合并表头）
weixin_39790510的博客
02-16 480
packageorg.alanlau.common.util;importorg.apache.commons.fileupload.disk.DiskFileItem;importorg.apache.commons.fileupload.disk.DiskFileItemFactory;importorg.apache.commons.lang3.time.DateFormatUtils;im...
poi 合并单元格_Springboot导出excel，合并单元格示例
weixin_39787397的博客
12-06 527
Java知音网站链接：www.javazhiyin.com/27467.html以下用一个示例来说明springboot如何导出数据到excel。首先引入Maven依赖： org.apache.poi poi 3.17 org.apache.poi poi-ooxml 3.17 org.apache.poi poi-oox...
springboot功能模块之POI操作Excel
最新发布
qq_62377885的博客
08-19 976
Apache POI项目的任务是创建和维护Java API，以基于Office OpenXML标准（OOXML）和Microsoft的OLE 2复合文档格式（OLE2）来处理各种文件格式。简而言之，您可以使用Java读写MSExcel文件。此外，您可以使用Java读写MS Word和MS PowerPoint文件。Apache POI是您的Java Excel解决方案（适用于Excel 97-2008）。基本功能HSSF － 提供读写格式档案的功能。XSSF － 提供读写Microsoft。
使用自定义注解+POI实现通用的表格导入导出
qq_21309199的博客
07-26 1395
之前做过单表格的导入导出，现在由于项目的需要，对很多表都要执行导入导出功能。如果每张表都单独去写导入导出，未免太麻烦了一些，后来考虑做一个通用的导入导出。1 首先要实现通用的导出功能 导出可以根据数据库中表的字段来导出，至于哪些字段需要导出，哪些不需要，可以通过注解来实现。 （1）首先定义导入导出的注解/** * 导入导出配置 */ @Retention(RetentionPolicy.RU
POI导出Excel、JAVA根据POI封装Excel的导出（支持动态表头）
lq6812574的博客
09-13 2214
根据POI封装Excel的导出（）说明代码 说明 之前不知道有easy-poi这个封装好的包。在使用poi的过程中，慢慢的根据实际业务封装的。 通过注解方式，生成Excel，支持动态表头。 代码 代码从接口调用开始说明 poi版本 ...
Java-poi导入excel合并单元格
Bronna的博客
09-14 4583
要导入的excel示例 一、Action @Action("/import-excel") public void toimport() { String root = ServletActionContext.getServletContext().getRealPath("/") + fileName; if (!StringUtils....
spring boot poi excel导入 合并 单元格
往生的博客
08-24 2117
导入excel若存在合并单元格，第一个单元格能取到值而合并的其他单元格则为空。 如图1A值为“场景名称”2A则为空，1B为“版本1.1”1C到1E则全为空。所以表头的设定是需要商榷好的。下面的方法可以一行一行的读取到每个单元格的值，包括合并单元的值。实际使用中2A的值可以用1A来填充，因为两者是合并的关系。而3A是有值的就不需要用2A的值来填充了，以此类推。 首先要引入依赖： ...
poi导出实现（多级表头合并单元格，自适应列宽，表格样式修改）
aa11dddd的博客
05-18 2828
2，编写对应的表头和样式，注意列宽自适应的配置。3，表头编写完成后，动态编写数据。6，将值填充到单元格中的方法。4，注意自适应列宽配置，7，创建表格样式的方法。8，最后的效果图如下。
Excel 导入 数据 spring boot
03-05
总的来说，通过Spring Boot结合Apache POI库，我们可以方便地实现Excel文件的上传和数据导入。这为处理大量结构化数据提供了灵活的解决方案，极大地提高了开发效率。在实际应用中，还可以根据需求进行优化，例如增加...
Spring Boot中实现列表数据导出为Excel文件
02-22
本文将详细介绍如何利用Apache POI库在Spring Boot框架中实现这一功能。 #### 二、Apache POI简介 Apache POI是一个强大的Java库，用于处理Microsoft Office格式的文件，如Excel、Word、PowerPoint等。它由Apache...
springboot 导出excel 导入excel 生成excel 内容有点多
03-27
在Spring Boot应用中，处理Excel文件的导出、导入和生成是常见的需求，尤其是在数据分析、报表生成和数据迁移等场景。下面将详细讲解如何在Spring Boot项目中实现这些功能。 ### 1. Excel导出 要导出Excel文件，...
POI读取Excel合并单元格并储存
01-22
Java操纵POI解析Excel表，根据表头将内容储存。通过实体类set、get方便其它方法引用
SpringBoot整合POI导出通用Excel的方法示例
08-24
主要介绍了SpringBoot整合POI导出通用Excel的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
POI导入导出及动态复杂表头生成
日月忽其不淹兮，春与秋其代序 认知即成长
07-25 9746
在此之前打开POI分类已存在三篇文章介绍了POI的使用及流下载，近期项目发现之前的使用中是有缺陷的，今天做一下总结，从现在起我们可以忽略前三篇文章对POI的使用，但是流下载方式还是可以参考的，这里还是再提一笔，流下载使用ajax会出异常，不生效，我是用的是提交form表单的方式来进行流下载，很遗憾，暂时取不到返回值        下面我们继续谈一下POI的使用        首先需要强调几点，
JAVA POI 实现EXCEL 动态表头、动态添加数据（导入导出）、 Tree结构的遍历
热门推荐
嘻哈嘻哈
05-29 6万+
一、JAVA POI 实现EXCEL 工具类 我们目的是要建立一个EXCEL的工具类，它的功能： 1、可以生成动态表头，单级，多级都支持，尤其是树形表头（整体思路按照树形结构数据来遍历）； 2、数据可配置，支持动态填写数据（一个List结构的数据）； 3、读取Excel数据； 设计思路：需要一个含有树形结构的实体类Column，用于转换外部数据；而且该实体类要记录下它自己在EXCEL表中...
使用Easy-POI导入复杂表头的Excel报表（含源码级分析）
cxlswh的博客
05-05 1万+
本文旨在解决使用Easy-POI导入复杂表头（导出）时，遇上的EXCEL文件中的字段无法正常映射到Bean的问题,官方的示例和其他的CSDN文章基本上没有很详细的教程，于是自己写一个 这是需要导入的表结构： 这是结构中需要在ImportParams中声明的术语： 在导入的时候，必须通过ImportParams params = new ImportParams()对象设置表的基本结构，如果有标题，就要params.setTitleRows(1)设置忽略的行，标题占1行就设置1，占n行就设置n，这个很容易
POI导入数据解决多表头，合并单元格数据读取问题
weixin_47064169的博客
12-18 5569
poi导入数据解决多表头，合并单元格数据读取问题
Excel导入表头名称重复处理 多级表头合并单元格的标题导入数据
zhy的博客
04-01 2892
背景 由于业务需求是excel模板不可以修改，但是excel表中的表头是重复的，目前使用的控件会取最后一个赋值，前面的都丢弃了。并且有的表格还是多级表头的情况。 解决办法 使用的是ruoyi框架中的导入方法，对此方法进行了简单的改造 第262行进行修改 // 获取表头 Row heard = sheet.getRow(titleNum); int nullIndex = 1; for (int i = 0; i < heard
excel多表头导入
Java_Destiny的博客
04-19 683
【代码】excel导出。
使用Apache POI实现Excel导入Java服务
InnovateTianAction.java 是一个Java类，主要关注于利用Apache POI库进行Excel导入的功能实现。POI（Poor Obfuscation Implementation）是一个广泛用于处理Microsoft Office文件格式的Java API，特别是Excel (.xls) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值