精华内容
下载资源
问答
  • EasyPoi

    2020-12-04 15:42:20
    EasyPoi 1.0 通用样式 2.0 样式文件 package com.gcb.platform.utils.easyPoi; import cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity; import ...

    EasyPoi

    1.0 通用样式

    image-20201125103427010

    2.0 样式文件

    package com.gcb.platform.utils.easyPoi;
    
    import cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity;
    import cn.afterturn.easypoi.excel.entity.params.ExcelForEachParams;
    import cn.afterturn.easypoi.excel.export.styler.IExcelExportStyler;
    import org.apache.poi.ss.usermodel.BorderStyle;
    import org.apache.poi.ss.usermodel.BuiltinFormats;
    import org.apache.poi.ss.usermodel.Cell;
    import org.apache.poi.ss.usermodel.CellStyle;
    import org.apache.poi.ss.usermodel.Font;
    import org.apache.poi.ss.usermodel.HorizontalAlignment;
    import org.apache.poi.ss.usermodel.VerticalAlignment;
    import org.apache.poi.ss.usermodel.Workbook;
    
    /**
     * author Mr.ALan
     * DESCRIPTION 设置导出表格的基础样式
     * create 2019/12/25
     */
    
    public class ExcelStyleUtil implements IExcelExportStyler {
        private static final short STRING_FORMAT = (short) BuiltinFormats.getBuiltinFormat("TEXT");
        private static final short FONT_SIZE_TEN = 10;
        private static final short FONT_SIZE_ELEVEN = 11;
        private static final short FONT_SIZE_TWELVE = 12;
        /**
         * 大标题样式
         */
        private CellStyle headerStyle;
        /**
         * 每列标题样式
         */
        private CellStyle titleStyle;
        /**
         * 数据行样式
         */
        private CellStyle styles;
    
        public ExcelStyleUtil(Workbook workbook) {
            this.init(workbook);
        }
    
        /**
         * 初始化样式
         *
         * @param workbook
         */
        private void init(Workbook workbook) {
            this.headerStyle = initHeaderStyle(workbook);
            this.titleStyle = initTitleStyle(workbook);
            this.styles = initStyles(workbook);
        }
    
        /**
         * 大标题样式
         *
         * @param color
         * @return
         */
        @Override
        public CellStyle getHeaderStyle(short color) {
            return headerStyle;
        }
    
        /**
         * 每列标题样式
         *
         * @param color
         * @return
         */
        @Override
        public CellStyle getTitleStyle(short color) {
            return titleStyle;
        }
    
        /**
         * 数据行样式
         *
         * @param parity 可以用来表示奇偶行
         * @param entity 数据内容
         * @return 样式
         */
        @Override
        public CellStyle getStyles(boolean parity, ExcelExportEntity entity) {
            return styles;
        }
    
        /**
         * 获取样式方法
         *
         * @param dataRow 数据行
         * @param obj     对象
         * @param data    数据
         */
        @Override
        public CellStyle getStyles(Cell cell, int dataRow, ExcelExportEntity entity, Object obj, Object data) {
            return getStyles(true, entity);
        }
    
        /**
         * 模板使用的样式设置
         */
        @Override
        public CellStyle getTemplateStyles(boolean isSingle, ExcelForEachParams excelForEachParams) {
            return null;
        }
    
        /**
         * 初始化--大标题样式
         *
         * @param workbook
         * @return
         */
        private CellStyle initHeaderStyle(Workbook workbook) {
            CellStyle style = getBaseCellStyle(workbook);
            style.setFont(getFont(workbook, FONT_SIZE_TWELVE, true));
            return style;
        }
    
        /**
         * 初始化--每列标题样式
         *
         * @param workbook
         * @return
         */
        private CellStyle initTitleStyle(Workbook workbook) {
            CellStyle style = getBaseCellStyle(workbook);
            style.setFont(getFont(workbook, FONT_SIZE_ELEVEN, false));
            return style;
        }
    
        /**
         * 初始化--数据行样式
         *
         * @param workbook
         * @return
         */
        private CellStyle initStyles(Workbook workbook) {
            CellStyle style = getBaseCellStyle(workbook);
            style.setFont(getFont(workbook, FONT_SIZE_TEN, false));
            style.setDataFormat(STRING_FORMAT);
            return style;
        }
    
        /**
         * 基础样式
         *
         * @return
         */
        private CellStyle getBaseCellStyle(Workbook workbook) {
            CellStyle style = workbook.createCellStyle();
            // 下边框
            style.setBorderBottom(BorderStyle.THIN);
            // 左边框
            style.setBorderLeft(BorderStyle.THIN);
            // 上边框
            style.setBorderTop(BorderStyle.THIN);
            // 右边框
            style.setBorderRight(BorderStyle.THIN);
            // 水平居中
            style.setAlignment(HorizontalAlignment.CENTER);
            //上下居中
            style.setVerticalAlignment(VerticalAlignment.CENTER);
            // 设置自动换行
            style.setWrapText(false);
            return style;
        }
    
        /**
         * 字体样式
         *
         * @param size   字体大小
         * @param isBold 是否加粗
         * @return
         */
        private Font getFont(Workbook workbook, short size, boolean isBold) {
            Font font = workbook.createFont();
            // 字体样式
            font.setFontName("宋体");
            // 是否加粗
            font.setBold(isBold);
            // 字体大小
            font.setFontHeightInPoints(size);
            return font;
        }
    }
    

    3.0 EasyPoi 工具类

    package com.gcb.platform.utils.easyPoi;
    
    import cn.afterturn.easypoi.excel.ExcelExportUtil;
    import cn.afterturn.easypoi.excel.entity.ExportParams;
    import cn.afterturn.easypoi.excel.entity.TemplateExportParams;
    import cn.afterturn.easypoi.excel.entity.enmus.ExcelType;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.poi.ss.usermodel.Workbook;
    
    import javax.servlet.http.HttpServletResponse;
    import javax.ws.rs.core.MediaType;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.URLEncoder;
    import java.nio.charset.StandardCharsets;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * author Mr.ALan
     * DESCRIPTION 使用自定义的表格样式导出文件
     * create 2019/12/25
     */
    
    @Slf4j
    public class OfficeExportUtil {
    
        /**
         * 允许导出的最大条数
         */
        private static final Integer EXPORT_EXCEL_MAX_NUM = 100000;
    
        /**
         * 获取导出的 Workbook对象
         *
         * @param title     大标题
         * @param sheetName 页签名
         * @param object    导出实体
         * @param list      数据集合
         * @return Workbook
         */
        public static Workbook getWorkbook(String title, String sheetName, Class object, List list) {
            //判断导出数据是否为空
            if (list == null) {
                list = new ArrayList<>();
            }
            //判断导出数据数量是否超过限定值
            if (list.size() > EXPORT_EXCEL_MAX_NUM) {
                title = "导出数据行数超过:" + EXPORT_EXCEL_MAX_NUM + "条,无法导出、请添加导出条件!";
                list = new ArrayList<>();
            }
            //获取导出参数
            ExportParams exportParams = new ExportParams(title, sheetName, ExcelType.HSSF);
            //设置导出样式
            exportParams.setStyle(ExcelStyleUtil.class);
            //输出Workbook流
            return ExcelExportUtil.exportExcel(exportParams, object, list);
        }
    
        /**
         * 使用easyPoi导出含有多个sheet的excel
         *
         * @param titles  按照顺序存放标题名称
         * @param sheets  按照顺序存放sheet名称
         * @param objects 按照顺序存放导出的实体字节码对象
         * @param data    按照顺序存放要导出来的数据集合
         * @return
         */
        public static Workbook getWorkbook(List<String> titles,List<String> sheets, List<Class> objects, List<List> data) {
            List<Map<String, Object>> sheetsList = new ArrayList<>(titles.size());
            for (int i = 0; i < titles.size(); i++) {
                // 创建参数对象(用来设定excel得sheet得内容等信息)
                ExportParams exportParams = new ExportParams();
                exportParams.setStyle(ExcelStyleUtil.class);
                // 设置sheet得名称
                exportParams.setSheetName(sheets.get(i));
                exportParams.setTitle(titles.get(i));
                // 创建sheet1使用得map
                Map<String, Object> exportMap = new HashMap<>();
                // title的参数为ExportParams类型,
                exportMap.put("title", exportParams);
                // 模版导出对应得实体类型
                exportMap.put("entity", objects.get(i));
                // sheet中要填充得数据
                exportMap.put("data", data.get(i));
                // 将sheet使用添加到添加到集合总
                sheetsList.add(exportMap);
            }
            return ExcelExportUtil.exportExcel(sheetsList, ExcelType.HSSF);
        }
    
        /**
         * 获取导出的 Workbook对象
         *
         * @param path 模板路径
         * @param map  导出内容map
         * @return Workbook
         */
        public static Workbook getWorkbook(String path, Map<String, Object> map) {
            //获取导出模板
            TemplateExportParams params = new TemplateExportParams(path);
            //设置导出样式
            params.setStyle(ExcelStyleUtil.class);
            //输出Workbook流
            return ExcelExportUtil.exportExcel(params, map);
        }
    
        /**
         * 导出Excel
         *
         * @param workbook workbook流
         * @param fileName 文件名
         * @param response 响应
         */
        public static void exportExcel(Workbook workbook, String fileName, HttpServletResponse response) {
            // 拼接上文件的后缀
            if (!fileName.contains("xlsx")){
                fileName = fileName + ".xls";
            }
            //输出文件
            try (OutputStream outStream = response.getOutputStream()) {
                if (fileName.contains("xlsx")){
                    response.setContentType("application/xlsx;charset=gbk");
                } else {
                    response.setContentType("application/xls;charset=gbk");
                }
                fileName = URLEncoder.encode(fileName, StandardCharsets.UTF_8.toString());
                response.setContentType(MediaType.APPLICATION_OCTET_STREAM);
                response.setHeader("Content-Disposition", "attachment; filename=" + fileName + "; filename*=utf-8''" + fileName);
                workbook.write(outStream);
            } catch (IOException e) {
                log.error("文件导出异常:", e);
            }
        }
    }
    

    4.0 注解导出

    1. 添加导出的实体,并添加相对的注解

      package com.gcb.platform.model.excelExport;
      
      import cn.afterturn.easypoi.excel.annotation.Excel;
      import lombok.Data;
      
      import java.util.Date;
      
      /**
       * author Mr.ALan
       * DESCRIPTION 用户评价导出实体
       * create 2019/12/27
       */
      @Data
      public class Comment {
      
          @Excel(name = "订单编号",width = 18)
          private String taskCode;
      
          @Excel(name = "报修时间",width = 22)
          private String taskTime;
      
          @Excel(name = "报修产品",width = 20)
          private String equipmentName;
      
          @Excel(name = "报修位置",width = 22)
          private String address;
      
          @Excel(name = "故障描述",width = 20)
          private String description;
      
          @Excel(name = "品牌",width = 15)
          private String eqBrand;
      
          @Excel(name = "型号")
          private String eqNum;
      
          @Excel(name = "报修人")
          private String publisherName;
      
          @Excel(name = "报修人电话",width = 18)
          private String phone;
      
          @Excel(name = "处理人")
          private String handleName;
      
          @Excel(name = "评价时间",width = 22,format = "yyyy-MM-dd HH:mm:ss")
          private Date creationTime;
      
          @Excel(name = "评价等级")
          private String scoreLevel;
      
          @Excel(name = "评分")
          private Float score;
      
          @Excel(name = "评价标签",width = 20)
          private String tags;
      
          @Excel(name = "评价内容",width = 40)
          private String text;
      
      }
      
      
    2. 查询数据并导出

      {
          // 获取导出的数据
          List<Comment> list = getList();
          //写表头
          String title = "标题";
          String fileName = "用户评价表";
          OfficeExportUtil.exportExcel(
              OfficeExportUtil.getWorkbook(title, "用户评价表", Comment.class, list), 					fileName, response);
      }
      
    展开全文
  • EasyPOI

    2021-09-15 16:32:06
    EasyPOI简介官网介绍独特的功能引入POMExcel注解版基本注解例1-基本功能示例@Excel注解参数例2-单元格宽度及格式示例例3-部分属性功能示例例4-list导出例5-一对一对象导出例6-一对多对象导出例7-大数据量导出例8-...

    简介

    官网

    http://doc.wupaas.com/docs/easypoi/easypoi-1c0u6ksp2r091

    介绍

    Easypoi的目标不是替代poi,而是让一个不懂导入导出的快速使用poi完成Excel和word的各种操作,而不是看很多api才可以完成这样工作

    独特的功能

    • 基于注解的导入导出,修改注解就可以修改Excel
    • 支持常用的样式自定义
    • 基于map可以灵活定义的表头字段
    • 支持一堆多的导出,导入
    • 支持模板的导出,一些常见的标签,自定义标签
    • 支持HTML/Excel转换,如果模板还不能满足用户的变态需求,请用这个功能
    • 支持word的导出,支持图片,Excel

    引入POM

    • 1.easypoi 父包–作用大家都懂得
    • 2.easypoi-annotation 基础注解包,作用与实体对象上,拆分后方便maven多工程的依赖管理
    • 3.easypoi-base 导入导出的工具包,可以完成Excel导出,导入,Word的导出,Excel的导出功能
    • 4.easypoi-web 耦合了spring-mvc 基于AbstractView,极大的简化spring-mvc下的导出功能
    • 5.sax 导入使用xercesImpl这个包(这个包可能造成奇怪的问题哈),word导出使用poi-scratchpad,都作为可选包了

    如果不使用spring mvc的便捷福利,直接引入easypoi-base 就可以了,easypoi-annotation

    如果使用maven,请使用如下坐标

    	<dependency>
          <groupId>cn.afterturn</groupId>
          <artifactId>easypoi-base</artifactId>
          <version>4.1.0</version>
        </dependency>
        <dependency>
          <groupId>cn.afterturn</groupId>
          <artifactId>easypoi-web</artifactId>
          <version>4.1.0</version>
        </dependency>
        <dependency>
          <groupId>cn.afterturn</groupId>
          <artifactId>easypoi-annotation</artifactId>
          <version>4.1.0</version>
        </dependency>
    

    Excel注解版

    基本注解

    easypoi起因就是Excel的导入导出,最初的模板是实体和Excel的对应,model–row,filed–col 这样利用注解我们可以和容易做到excel到导入导出
    经过一段时间发展,现在注解有5个类分别是

    • @Excel 作用到filed上面,是对Excel一列的一个描述
    • @ExcelCollection 表示一个集合,主要针对一对多的导出,比如一个老师对应多个科目,科目就可以用集合表示
    • @ExcelEntity 表示一个继续深入导出的实体,但他没有太多的实际意义,只是告诉系统这个对象里面同样有导出的字段
    • @ExcelIgnore 和名字一样表示这个字段被忽略跳过这个导导出
    • @ExcelTarget 这个是作用于最外层的对象,描述这个对象的id,以便支持一个对象可以针对不同导出做出不同处理

    例1-基本功能示例

    实体类

    @Data
    @ExcelTarget("User表")
    public class User implements Serializable {
    
        @Excel(name = "编号")
        private String id;
        @Excel(name = "姓名")
        private String name;
        @Excel(name = "年龄")
        private Integer age;
        @Excel(name = "生日")
        private Date bir;
    
    }
    

    业务类

    //模拟查询数据库
    public List<User> getUsers(){
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(String.valueOf(i));
            user.setName("sb"+i);
            user.setAge(5+i);
            user.setBir(new Date());
            users.add(user);
        }
        return users;
    }
    
    @Test
    public void testExport() throws IOException {
        // 获取数据
        List<User> users = getUsers();
        // 导出excel
        // 参数1:exportParams 导出配置对象 参数2:导出的类型 参数3:导出数据集合
        Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams("用户信息表", "用户信息"), User.class, users);
        // 将excel写入指定位置
        FileOutputStream outputStream = new FileOutputStream("E:\\新建文件夹\\test.xlsx");
        workbook.write(outputStream);
        outputStream.close();
        workbook.close();
    }
    

    结果
    在这里插入图片描述

    @Excel注解参数

    这个是必须使用的注解,如果需求简单只使用这一个注解也是可以的,涵盖了常用的Excel需求,需要大家熟悉这个功能,主要分为基础,图片处理,时间处理,合并处理几块,name_id是上面讲的id用法,这里就不累言了

    属性类型默认值功能
    nameStringnull列名,支持name_id
    needMergebooleanfasle是否需要纵向合并单元格(用于含有list中,单个的单元格,合并list创建的多个row)
    orderNumString“0”列的排序,支持name_id
    replaceString[]{}值得替换 导出是{a_id,b_id} 导入反过来
    savePathString“upload”导入文件保存路径,如果是图片可以填写,默认是upload/className/ IconEntity这个类对应的就是upload/Icon/
    typeint1导出类型 1 是文本 2 是图片,3 是函数,10 是数字 默认是文本
    widthdouble10列宽
    heightdouble10列高,后期打算统一使用@ExcelTarget的height,这个会被废弃,注意
    isStatisticsbooleanfasle自动统计数据,在追加一行统计,把所有数据都和输出[这个处理会吞没异常,请注意这一点]
    isHyperlinkbooleanfalse超链接,如果是需要实现接口返回对象
    isImportFieldbooleantrue校验字段,看看这个字段是不是导入的Excel中有,如果没有说明是错误的Excel,读取失败,支持name_id
    exportFormatString“”导出的时间格式,以这个是否为空来判断是否需要格式化日期
    importFormatString“”导入的时间格式,以这个是否为空来判断是否需要格式化日期
    formatString“”时间格式,相当于同时设置了exportFormat 和 importFormat
    databaseFormatString“yyyyMMddHHmmss”导出时间设置,如果字段是Date类型则不需要设置 数据库如果是string 类型,这个需要设置这个数据库格式,用以转换时间格式输出
    numFormatString“”数字格式化,参数是Pattern,使用的对象是DecimalFormat
    imageTypeint1导出类型 1 从file读取 2 是从数据库中读取 默认是文件 同样导入也是一样的
    suffixString“”文字后缀,如% 90 变成90%
    isWrapbooleantrue是否换行 即支持\n
    mergeRelyint[]{}合并单元格依赖关系,比如第二列合并是基于第一列 则{0}就可以了
    mergeVerticalbooleanfasle纵向合并内容相同的单元格
    fixedIndexint-1对应excel的列,忽略名字
    isColumnHiddenbooleanfalse导出隐藏列

    例2-单元格宽度及格式示例

    我们发现在例1中所创建出来的单元格大小都一致,从而就出现了压缩长单元格内容的问题,利用上述的参数width即可改变

    实体类

    @Data
    @ExcelTarget("User表")
    public class User implements Serializable {
    
        @Excel(name = "编号")
        private String id;
        @Excel(name = "姓名")
        private String name;
        @Excel(name = "年龄")
        private Integer age;
        // 改变单元格宽度及日期的时间格式
        @Excel(name = "生日",width=35,format = "yyyy-MM-dd HH:mm:ss")
        private Date bir;
    
    }
    

    结果

    在这里插入图片描述

    例3-部分属性功能示例

    实体类

    @Data
    @ExcelTarget("User表")
    public class User implements Serializable {
    
        // orderNum可以使每一列按照从小到大的方式排列,值越小的列越靠左
        @Excel(name = "编号",orderNum = "0")
        private String id;
        @Excel(name = "姓名",orderNum = "1")
        private String name;
        @Excel(name = "年龄",orderNum = "2")
        private Integer age;
        // 改变单元格宽度及日期的时间格式
        @Excel(name = "生日",width=35,format = "yyyy-MM-dd HH:mm:ss",orderNum = "4")
        private Date bir;
        // replace的格式为{"xx_xx","xx_xx"...},在“_”之前的为将要替换成的值,之后的为被替换掉的值
        @Excel(name = "用户状态",replace = {"激活_1","锁定_0"},orderNum = "5")
        private Integer status;
        // suffix将会在值后加一个后缀
        @Excel(name = "存款",suffix = "$",orderNum = "3")
        private Integer money;
    
    }
    

    业务类

    //模拟查询数据库
    public List<User> getUsers(){
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(String.valueOf(i));
            user.setName("sb"+i);
            user.setAge(5+i);
            user.setBir(new Date());
            if (i%2==0){
                user.setStatus(1);
            }else
                user.setStatus(0);
            user.setMoney(i*50);
            users.add(user);
        }
        return users;
    }
    

    结果

    在这里插入图片描述

    例4-list导出

    实体类

    // @ExcelIgnore可以忽略该属性的导出
    @ExcelIgnore
    private List<String> habbys;
    // 为了让上方的list能够正常的按格式导出,我们使用以下方式,将list拼接成一个字符串,再导出
    @Excel(name = "爱好", width = 20, orderNum = "6")
    private String habbyStr;
    
    public String getHabbyStr() {
        final StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < habbys.size(); i++) {
            stringBuilder.append(habbys.get(i));
            if (i < habbys.size() - 1) {
                stringBuilder.append("、");
            }
        }
        return stringBuilder.toString();
    }
    

    业务类

    //模拟查询数据库
    public List<User> getUsers(){
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(String.valueOf(i));
            user.setName("sb"+i);
            user.setAge(5+i);
            user.setBir(new Date());
            user.setCard(card);
            if (i%2==0){
                user.setStatus(1);
                user.setHabbys(Arrays.asList("唱","跳","rap"));
            }else {
                user.setStatus(0);
                user.setHabbys(Arrays.asList("dota","lol","wow"));
            }
            user.setMoney(i*50);
            users.add(user);
        }
        return users;
    }
    

    结果

    在这里插入图片描述

    例5-一对一对象导出

    实体类

    // @ExcelEntity标志此为一对一关系
    @ExcelEntity
    private Card card;
    
    @Data
    @ExcelTarget("身份证信息")
    public class Card implements Serializable {
    
        //此处的orderNum也可以用来主序排列
        @Excel(name = "身份证号码",width = 20,orderNum = "7")
        private String cardID;
        @Excel(name = "住址",width = 20,orderNum = "8")
        private String address;
    }
    

    业务类

    //模拟查询数据库
    public List<User> getUsers(){
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(String.valueOf(i));
            user.setName("sb"+i);
            user.setAge(5+i);
            user.setBir(new Date());
            Card card = new Card();
            card.setCardID("这里是身份证号!");
            card.setAddress("桃花源北区8栋2单元"+i+"楼");
            user.setCard(card);
            if (i%2==0){
                user.setStatus(1);
                user.setHabbys(Arrays.asList("唱","跳","rap"));
            }else {
                user.setStatus(0);
                user.setHabbys(Arrays.asList("dota","lol","wow"));
            }
            user.setMoney(i*50);
            users.add(user);
        }
        return users;
    }
    

    结果

    在这里插入图片描述

    例6-一对多对象导出

    实体类

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ExcelTarget("订单信息")
    public class Order implements Serializable {
        @Excel(name = "订单号",width = 15,orderNum = "9")
        private String orderID;
        @Excel(name = "订单名",width = 10,orderNum = "10")
        private String orderName;
    }
    
    // @ExcelCollection标志此为一对多关系
    @ExcelCollection(name = "订单列表",orderNum = "8")
    private List<Order> orders;
    

    业务类

    //模拟查询数据库
    public List<User> getUsers(){
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setId(String.valueOf(i));
            user.setName("sb"+i);
            user.setAge(5+i);
            user.setBir(new Date());
            // 身份
            Card card = new Card();
            card.setCardID("这里是身份证号!");
            card.setAddress("桃花源北区8栋2单元"+i+"楼");
            user.setCard(card);
            // 订单
            List<Order> orders = new ArrayList<>();
            orders.add(new Order("12"+i,"可莉"));
            orders.add(new Order("12"+i,"刻晴"));
            orders.add(new Order("12"+i,"神里"));
            user.setOrders(orders);
            if (i%2==0){
                user.setStatus(1);
                user.setHabbys(Arrays.asList("唱","跳","rap"));
            }else {
                user.setStatus(0);
                user.setHabbys(Arrays.asList("dota","lol","wow"));
            }
            user.setMoney(i*50);
            users.add(user);
        }
        return users;
    }
    

    结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tya2kSGa-1631694702529)(笔记图片/在这里插入图片描述
    )]

    例7-大数据量导出

    大数据导出是当我们的导出数量在几万,到上百万的数据时,一次从数据库查询这么多数据加载到内存然后写入会对我们的内存和CPU都产生压力,这个时候需要我们像分页一样处理导出分段写入Excel缓解Excel的压力 EasyPoi提供的是两个方法 **强制使用 xssf版本的Excel **

    最好大量数据进行分页处理,每次导出数据最好不要超过1w条记录。

    业务类

    @Test
    public void testBigExport() throws IOException {
        // 获取数据
        List<User> users = getUsers();
        // 导出excel
        // 参数1:exportParams 导出配置对象 参数2:导出的类型 参数3:导出数据集合
        Workbook workbook = ExcelExportUtil.exportBigExcel(new ExportParams("用户列表","测试"), User.class,users);
        // 将excel写入指定位置
        FileOutputStream outputStream = new FileOutputStream("E:\\新建文件夹\\big.xlsx");
        workbook.write(outputStream);
        outputStream.close();
        workbook.close();
    }
    

    例8-导入

    实体类

    属性上的注解name必须和表头一致

    @Data
    @ExcelTarget("emps")
    public class Emp implements Serializable {
        @Excel(name = "编号")
        private String id;
        @Excel(name = "姓名")
        private String name;
        @Excel(name = "年龄")
        private Integer age;
        @Excel(name = "生日",format = "yyyy-MM-dd HH:mm:ss")
        private Date bir;
        @Excel(name = "用户状态",replace = {"激活_1", "锁定_0"})
        private String status;
    
    }
    

    业务类

    @Test
    public void testImport() throws Exception {
        // 参数1:导入excel文件流 参数2:导入的类型 参数3:导入的配置对象
        ImportParams params = new ImportParams();
        // 设置标题占几列
        params.setTitleRows(1);
        // 设置header列占几行
        params.setHeadRows(2);
        List<Emp> emps = ExcelImportUtil.importExcel(new FileInputStream("E:\\新建文件夹\\test.xlsx"), Emp.class, params);
    
        emps.forEach(System.out::println);
    }
    

    在这里插入图片描述

    展开全文
  • easypoi

    2020-02-11 21:33:40
    easypoi环境搭建Excel导出(包含多sheet导出)Excel导入 环境搭建 <!-- easypoi导入导出excel --> <dependency> <groupId>cn.afterturn</groupId> <artifactId>easypoi-base<...

    环境搭建

    		<!-- easypoi导入导出excel -->
          <dependency>
              <groupId>cn.afterturn</groupId>
              <artifactId>easypoi-base</artifactId>
              <version>3.1.0</version>
          </dependency>
          <dependency>
              <groupId>cn.afterturn</groupId>
              <artifactId>easypoi-web</artifactId>
              <version>3.1.0</version>
          </dependency>
          <dependency>
              <groupId>cn.afterturn</groupId>
              <artifactId>easypoi-annotation</artifactId>
              <version>3.1.0</version>
          </dependency>
          <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
    	<dependency>
    	    <groupId>org.apache.poi</groupId>
    	    <artifactId>poi</artifactId>
    	    <version>3.17</version>
    	</dependency>
    	<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
    	<dependency>
    	    <groupId>org.apache.commons</groupId>
    	    <artifactId>commons-lang3</artifactId>
    	    <version>3.4</version>
    	</dependency>
    

    Excel导出(包含多sheet导出)

    import cn.afterturn.easypoi.excel.entity.ExportParams;
    import cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity;	
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    import org.apache.poi.ss.usermodel.Workbook;
    import cn.afterturn.easypoi.excel.entity.ExportParams;
    import cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity;
    import cn.afterturn.easypoi.excel.export.ExcelExportService;
    
    	@RequestMapping("/toExportExcel.action")
        public void export(HttpServletResponse response) {
    
            //表头设置
            List<ExcelExportEntity> hdList = new ArrayList<ExcelExportEntity>();
    
            ExcelExportEntity colEntity = new ExcelExportEntity("日期", "dt");
            colEntity.setNeedMerge(true);
            hdList.add(colEntity);
    
            colEntity = new ExcelExportEntity("产品PV", "pv");
            colEntity.setNeedMerge(true);
            hdList.add(colEntity);
    
            colEntity = new ExcelExportEntity("产品UV", "uv");
            colEntity.setNeedMerge(true);
            hdList.add(colEntity);
    
            ExcelExportEntity group_1 = new ExcelExportEntity("业务数据", "businessData");
            List<ExcelExportEntity> exportEntities = new ArrayList<ExcelExportEntity>();
            exportEntities.add(new ExcelExportEntity("数据1", "data1"));
            exportEntities.add(new ExcelExportEntity("数据2", "data2"));
            exportEntities.add(new ExcelExportEntity("数据3", "data3"));
            exportEntities.add(new ExcelExportEntity("数据4", "data4"));
            group_1.setList(exportEntities);
            hdList.add(group_1);
    
            //文件数据
            List<Map<String, Object>> bdList = new ArrayList<Map<String, Object>>();
            Map<String, Object> valMap = new HashMap<String, Object>();
            valMap.put("dt", "2019-11-26 22:16:30");
            valMap.put("pv", "产品测试1");
            valMap.put("uv", "产品测试2");
            List<Map<String, Object>> list_1 = new ArrayList<Map<String, Object>>();
            Map<String, Object> valMap_1 = new HashMap<String, Object>();
            valMap_1.put("data1", "1");
            valMap_1.put("data2", "2");
            valMap_1.put("data3", "3");
            valMap_1.put("data4", "4");
            list_1.add(valMap_1);
            valMap.put("businessData", list_1);
            bdList.add(valMap);
    		
    		ExportParams zyldtjbzbParam = new ExportParams();
    		//设置表格的sheet名称
            zyldtjbzbParam.setSheetName("数据表");
            //设置表格的标题
            zyldtjbzbParam.setTitle("数据表");
    		
    		//塞数据
    		Map<String, Object> zyldtjbzbMap = new HashMap<String, Object>();
            zyldtjbzbMap.put("title", zyldtjbzbParam);
            zyldtjbzbMap.put("entity", hdList);
            zyldtjbzbMap.put("data", bdList);
        	
        	//将每一个sheet的map塞入list中
        	List<Map<String, Object>> sheetsList = new ArrayList<Map<String, Object>>();
        	sheetsList.add(zyldtjbzbMap);
    
    		//参数:response,表格名称(英文),sheet集合
        	export(response,"sjb",sheetsList);
        }
        
    	//导出
    	public void export(HttpServletResponse response,String excelName,List<Map<String, Object>> sheetsList) {
          
        	Workbook workbook = new HSSFWorkbook();
        	
        	for(int i = 0; i < sheetsList.size();i++) {
        		ExcelExportService service = new ExcelExportService();
        		service.createSheetForMap(workbook, (ExportParams)sheetsList.get(i).get("title"), (List<ExcelExportEntity>)sheetsList.get(i).get("entity"), (List<Map<String, Object>>)sheetsList.get(i).get("data"));
        	}
        	setResponseHeader(response, excelName);
            write(workbook, response);
        }
    
    	private void setResponseHeader(HttpServletResponse response, String fileName) {
            try {
                fileName = new String(fileName.getBytes(), "UTF-8");
                response.setContentType("application/octet-stream;charset=UTF-8");
                response.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xls");
                response.addHeader("Pargam", "no-cache");
                response.addHeader("Cache-Control", "no-cache");
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    
    	private void write(Workbook book, HttpServletResponse response) {
            try {
                OutputStream os = response.getOutputStream();
                book.write(os);
                os.flush();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    

    Excel导入

    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;
    
    public class ImportExcelUtil {
    	
    	/** 
         * @param file 表格的流
         * @param sheetIndex sheet的序号,默认从0开始数
         */  
    	public static List<Map<String, String>> importExcel(File file,int sheetIndex) {
    		try {
    			//获取表格流
    			FileInputStream is = new FileInputStream(file);
    			//读取excel
    			Workbook workbook = new HSSFWorkbook(is);
    			//拿到第几个sheet
    			Sheet sheet = workbook.getSheetAt(sheetIndex);
    			//拿到最后一行的行数
    			int lastRowNum = sheet.getLastRowNum();
    			
    			//获取表头
    			Map<Integer, String> headMap = new HashMap<Integer, String>();
    			//读取表头所在的行,默认从0开始数
    			Row row = sheet.getRow(1);
    		    //获取最后一列的列数
    		    short lastCellNum = row.getLastCellNum();
    	        for (int j = 0; j < lastCellNum; j++) {
    	            Cell cell = row.getCell(j);
    	            headMap.put(j, cell.getStringCellValue());
    	        }
    	        
    	        //获取表体
    	        List<Map<String, String>> bodyList = new ArrayList<Map<String, String>>();
    	        //你的数据是从第几行开始的就是几,默认从0开始数
    	        for (int i = 2; i <= lastRowNum; i++) {
            		Map<String,String> map = new HashMap<String,String>();
    	        	Row rowBody = sheet.getRow(i);
    	        	//这里j的最大值以表头的列数为参考,因为内容有的可能没有值,就会少算
    	        	for (int j = 0; j < lastCellNum; j++) {
    	        		String value = getMergedRegionValueAndInfo(sheet,i,j);
    	        		if(value == null || "".equals(value)){
    		        		Cell cell = rowBody.getCell(j);
    		        		map.put(headMap.get(j), getCellValue(cell));
    	        		}else{
    	        			map.put(headMap.get(j), value);
    	        		}
    	        	}
    	        	bodyList.add(map);
    	        }
    	        return bodyList;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	public static String getCellValue(Cell cell) {
            String ret;
            try {
                switch (cell.getCellType()) {
                    case Cell.CELL_TYPE_BLANK:
                        ret = "";
                        break;
                    case Cell.CELL_TYPE_BOOLEAN:
                        ret = String.valueOf(cell.getBooleanCellValue());
                        break;
                    case Cell.CELL_TYPE_ERROR:
                        ret = null;
                        break;
                    case Cell.CELL_TYPE_FORMULA:
                        cell.setCellType(Cell.CELL_TYPE_STRING);
                        try {
                            ret = String.valueOf(cell.getStringCellValue());
                        } catch (IllegalStateException e) {
                            ret = String.valueOf(cell.getNumericCellValue());
                        }
                        break;
                    case Cell.CELL_TYPE_NUMERIC:
                        ret = cell.getNumericCellValue() + "";
                        if (HSSFDateUtil.isCellDateFormatted(cell)) {
                            Date date = cell.getDateCellValue();
                            if (date != null) {
                                ret = new SimpleDateFormat("yyyy-MM-dd").format(date);
                            } else {
                                ret = "";
                            }
                        } else {
                            ret = cell.getNumericCellValue() + "";
                            ret = subZeroAndDot(ret);
                        }
                        break;
                    case Cell.CELL_TYPE_STRING:
                        ret = cell.getRichStringCellValue().getString();
                        break;
                    default:
                        ret = "";
                }
            } catch (Exception e) {
                e.printStackTrace();
                ret = null;
            }
            return ret; // 有必要自行trim
        }
    
    	/**   
        * 获取合并单元格的值   
        * @param sheet   
        * @param row   
        * @param column   
        * @return   
        */    
        public static String getMergedRegionValueAndInfo(Sheet sheet ,int row , int column){    
        	String MergedVal="";
            int sheetMergeCount = sheet.getNumMergedRegions();    
            for(int i = 0 ; i < sheetMergeCount ; i++){    
                CellRangeAddress ca = sheet.getMergedRegion(i);    
                int firstColumn = ca.getFirstColumn();    
                int lastColumn = ca.getLastColumn();    
                int firstRow = ca.getFirstRow();    
                int lastRow = ca.getLastRow();    
                if(row >= firstRow && row <= lastRow){    
                    if(column >= firstColumn && column <= lastColumn){    
                        Row fRow = sheet.getRow(firstRow);    
                        Cell fCell = fRow.getCell(firstColumn);    
                        MergedVal=getCellValue(fCell);
                        return MergedVal ;    
                    }    
                }    
            }    
            return null ;    
        } 
    
    	private static String subZeroAndDot(String s) {
    	    if (s.indexOf(".0") > 0) {
    	        // 去掉多余的 
    	        s = s.replaceAll("0+?$", ""); 
    	       // 如果最后一位是.则去掉
    	        s = s.replaceAll("[.]$", "");
    	    } 
    	   return s;
    	}
    

    项目经验相关操作补充

    查看导入的数据中是否包含重复的数据

    对于数据量不大,不超过一万到两行的excel

    	//使用List集合将指定查重的字段存储起来
    	List<String> list = new ArrayList<String>();
    	for(){
    		//将指定查重字段存储到list,如果有多个字段,就把它拼起来放到list集合中
    	}
    	//查重
    	if(list.stream().distinct().count() == (long)(list.size())) {
    		//无重复
    	}else{
    		//有重复
    	}
    

    导入数据对于Oracle库中已经存在的数据操作

    通过使用触发器对于库中已经存在的数据:有就更新

    #创建触发器
    create or replace trigger jcStudentXX
    #触发条件:插入之前
    before
    insert
    on T_SCHTCSBB
    #对于每一行插入操作
    for each row
    declare
    v_count number;
    #对触发器的操作开启新的事务
    pragma autonomous_transaction;
    begin
      select count(*) into v_count from T_SCHTCSBB where studentSFZH = :new.studentSFZH and delestatus = '0';
      if (v_count > 0) then
      	#删除原来的数据
        delete from T_SCHTCSBB where studentSFZH = :new.studentSFZH and delestatus = '0';
        #提交触发器事务
        commit;
      end if;
    end;
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,043
精华内容 2,417
关键字:

easypoi