精华内容
下载资源
问答
  • 在项目中导出excel是难免不可缺少的,总结了一下,可以copy直接用。有什么地方不足的还请指出。 注意:这里固定了前台入参形式为json字符串,主要有两个key(title标题,data数据)如下:{"title":{},"data":[{},{}...

    在项目中导出excel是难免不可缺少的,总结了一下,可以copy直接用。有什么地方不足的还请指出。

    注意:这里固定了前台入参形式为json字符串,主要有两个key(title标题,data数据)如下:{"title":{},"data":[{},{},{}]}

    • pom依赖
             <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi</artifactId>
                <version>4.1.0</version>
            </dependency>
            
            <dependency>
                <groupId>net.sf.json-lib</groupId>
                <artifactId>json-lib</artifactId>
                <version>2.4</version>
                <classifier>jdk15</classifier>
            </dependency>
    • 工具类:ExcelUtil(如果方法报错,看一下是否导错包了,必须有json-lib jdk15的依赖哦)json-lib是一个java类库,用来处理json数据,包括生成和解析。
    package com.mycompany.myapp.web.rest.util;
    
    
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    import org.apache.poi.hssf.usermodel.*;
    import org.apache.poi.ss.usermodel.HorizontalAlignment;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    @Component
    public class ExcelExportUtil {
        //文件下载地址
        public static String DOWNLOAD_URL;
    
        @Value("${downloadUrl}")
        public void setDownloadUrl(String downloadUrl) {
            DOWNLOAD_URL = downloadUrl;
        }
    
        public static void outPutExcel(String jsonParam) throws Exception {
            JSONObject jsonObject = JSONObject.fromObject(jsonParam);
            //文件名
            String fileName = jsonObject.getString("fileName");
            //文件存放路径
            String url = DOWNLOAD_URL + fileName + ".xls";
            //标题
            String title = jsonObject.getString("title");
            JSONObject jsonObjectTitle = JSONObject.fromObject(title);
            String[] titleArray = new String[jsonObjectTitle.size()];
            Iterator iteratorTitle = jsonObjectTitle.keys();
            int m = 0;
            while (iteratorTitle.hasNext()){
                String key = (String)iteratorTitle.next();
                titleArray[m] = jsonObjectTitle.getString(key);
                m++;
            }
            //数据
            String data = jsonObject.getString("data");
            JSONArray jsonArray = JSONArray.fromObject(data);
            List<Object[]> dataList = new ArrayList<>();
            for(int i = 0;i<jsonArray.size();i++){
                JSONObject json = jsonArray.getJSONObject(i);
                Object[] objects = new Object[json.size()];
                Iterator iterator = json.keys();
                int n = 0;
                while (iterator.hasNext()){
                    String key = (String)iterator.next();
                    objects[n] = json.getString(key);
                    n++;
                }
                dataList.add(objects);
            }
    
            //字段为null时设置为""
            for(int i =0;i<dataList.size();i++){
                Object[] obj = dataList.get(i);
                for(int j = 0;j<obj.length;j++){
                    if(obj[j]==null||"null".equals(obj[j])){
                        obj[j] = "";
                    }
                }
            }
    
            //excel创建
            HSSFWorkbook workbook = new HSSFWorkbook();
            HSSFSheet sheet = workbook.createSheet(fileName);
            createTitle(workbook,sheet,titleArray);
    
            for(int i =0;i<dataList.size();i++){
                HSSFRow row = sheet.createRow(i+1);
                Object[] obj = dataList.get(i);
                for(int j = 0;j<obj.length;j++){
                    row.createCell(j).setCellValue(obj[j].toString());
                }
            }
    
            File file = new File(url);
            //文件不存在则创建
            if(!file.exists())
            {
                try {
                    file.createNewFile();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            FileOutputStream outputStream = new FileOutputStream(url);
            workbook.write(outputStream);
            outputStream.close();
        }
    
        //创建表头
        private static void createTitle(HSSFWorkbook workbook, HSSFSheet sheet,String[] titleArray) {
            HSSFRow row = sheet.createRow(0);
            //设置为居中加粗
            HSSFCellStyle style = workbook.createCellStyle();
            HSSFFont font = workbook.createFont();
            font.setBold(true);
            font.setFontName("仿宋");
            style.setAlignment(HorizontalAlignment.CENTER);
            style.setFont(font);
    
            HSSFCell cell;
            for(int i = 0;i<titleArray.length;i++){
                cell = row.createCell(i);
                cell.setCellValue(titleArray[i]);
                cell.setCellStyle(style);
                //自适应列宽
                sheet.autoSizeColumn((short)i);
            }
        }
    }
    
    • yml文件中自定义路径配置:
     比如:downloadUrl: /Users/parkin/Downloads/
    • 控制层调用:
     /**
         * 学校列表导出excel
         * @param jsonParam
         * @param response
         */
        @PostMapping(value = "/schoolsExcelExport",produces="application/octet-stream")
        @ResponseBody
        @PreAuthorize("hasRole(\""+ AuthoritiesConstants.ADMIN +"\")")
        public void schoolsExcelExport(@RequestBody String jsonParam, HttpServletResponse response) {
            try{
                String sheetName = "学校列表";
                //excel导出
                ExcelExportUtil.outPutExcel(jsonParam,response,sheetName);
            }
            catch (Exception ex){
                throw new BadRequestAlertException(ex.getMessage(),ENTITY_NAME,"param");
            }
        }
    • postman 测试:

    展开全文
  • SpringBoot POI导出Excel

    2020-08-29 20:25:40
    SpringBoot导出Excel <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId> <version>4.1.2</version> </dependency>

    SpringBoot导出Excel

    HSSFWorkbook、XSSFWorkbook、SXSSFWorkbook的区别:

    HSSFWorkbook一般用于Excel2003版及更早版本(扩展名为.xls)的导出。
    XSSFWorkbook一般用于Excel2007版(扩展名为.xlsx)的导出。
    SXSSFWorkbook一般用于大数据量的导出。
    

    注:HSSFWorkbook和XSSFWorkbook的Excel Sheet导出条数上限(<=2003版)是65535行、256列,(>=2007版)是
    1048576行,16384列,如果数据量超过了此上限,那么可以使用SXSSFWorkbook来导出。实际上上万条数据,
    甚至上千条数据就可以考虑使用SXSSFWorkbook了。

    HSSSFWorkbook 和SXSSFWorkbook在导出excel workbook对象在执行write方法写入数据到ServletOutputStream时 是有点区别的

    HSSFWorkbook在write方法执行完的时候并没有关闭流 ,所以我们可以对这个流统计大小来获取导出文件的大小,并且最后需要我们手动关闭
    而SXSSFWorkbook的write方法把流关闭了,write方法执行完之后out流就空了拿不到大小了

    SXSSFWorkbook是XSSFWorkbook的Streaming版本,实现了"BigGridDemo"的策略,在导出大量数据的时候,可以避免OOM。

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

    参考地址
    https://www.cnblogs.com/linjiqin/p/10975761.html

    https://www.jianshu.com/p/3a89e19a1bc3

    https://www.cnblogs.com/toutou/p/9857963.html

    https://blog.csdn.net/typ1805/article/details/83279532

    POI之SXSSFWorkbook大量数据导出至excel
    https://blog.csdn.net/k_520_w/article/details/84404652

    展开全文
  • Springboot 之 使用POI导出Excel文件

    万次阅读 2016-10-29 01:41:28
    本文章来自【知识林】前面讲述了使用POI导出Word文件和读取Excel文件,这两个例子都相对简单,接下来要讲述的使用POI导出Excel文件要复杂得多,内容也会比较长。 创建表头信息 表头信息用于自动生成表头结构及排序...

    本文章来自【知识林】

    前面讲述了使用POI导出Word文件读取Excel文件,这两个例子都相对简单,接下来要讲述的使用POI导出Excel文件要复杂得多,内容也会比较长。

    • 创建表头信息

    表头信息用于自动生成表头结构及排序

    public class ExcelHeader implements Comparable<ExcelHeader>{
        /**
         * excel的标题名称
         */
        private String title;
        /**
         * 每一个标题的顺序
         */
        private int order;
        /**
         * 说对应方法名称
         */
        private String methodName;
    
    
        public String getTitle() {
            return title;
        }
        public void setTitle(String title) {
            this.title = title;
        }
        public int getOrder() {
            return order;
        }
        public void setOrder(int order) {
            this.order = order;
        }
        public String getMethodName() {
            return methodName;
        }
        public void setMethodName(String methodName) {
            this.methodName = methodName;
        }
    
        public int compareTo(ExcelHeader o) {
            return order>o.order?1:(order<o.order?-1:0);
        }
        public ExcelHeader(String title, int order, String methodName) {
            super();
            this.title = title;
            this.order = order;
            this.methodName = methodName;
        }
    }
    • 表头信息的Annotation
    /**
     * 用来在对象的get方法上加入的annotation,通过该annotation说明某个属性所对应的标题
     * Created by 钟述林 393156105@qq.com on 2016/10/29 0:14.
     */
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ExcelResources {
        /**
         * 属性的标题名称
         * @return
         */
        String title();
        /**
         * 在excel的顺序
         * @return
         */
        int order() default 9999;
    }
    • 创建数据实体
    public class WebDto {
    
        //网站名称
        private String name;
    
        //网址
        private String url;
    
        //用户名
        private String username;
    
        //密码
        private String password;
    
        //日均访问量
        private Integer readCount;
    
        public WebDto(String name, String url, String username, String password, Integer readCount) {
            this.name = name;
            this.url = url;
            this.username = username;
            this.password = password;
            this.readCount = readCount;
        }
    
        public WebDto() {}
    
        @Override
        public String toString() {
            return "WebDto{" +
                    "name='" + name + '\'' +
                    ", url='" + url + '\'' +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", readCount=" + readCount +
                    '}';
        }
    
        @ExcelResources(title="网站名称",order=1)
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @ExcelResources(title="网址",order=2)
        public String getUrl() {
            return url;
        }
    
        public void setUrl(String url) {
            this.url = url;
        }
    
        @ExcelResources(title="用户名",order=3)
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        @ExcelResources(title="密码",order=4)
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @ExcelResources(title="日均访问量",order=5)
        public Integer getReadCount() {
            return readCount;
        }
    
        public void setReadCount(Integer readCount) {
            this.readCount = readCount;
        }
    }

    注意:这里使用到了@ExcelResources来自动识别表头信息及序号

    • 获取模板文件的工具类
    public class TemplateFileUtil {
    
        public static FileInputStream getTemplates(String tempName) throws FileNotFoundException {
            return new FileInputStream(ResourceUtils.getFile("classpath:excel-templates/"+tempName));
        }
    }

    注意:从这里可以看出,所有的Excel模板文件都放在resources/excel-templates/目录下。

    • 模板工具类

    通过此类可以自动复制表样式等功能

    /**
     * 该类实现了基于模板的导出
     * 如果要导出序号,需要在excel中定义一个标识为sernums
     * 如果要替换信息,需要传入一个Map,这个map中存储着要替换信息的值,在excel中通过#来开头
     * 要从哪一行那一列开始替换需要定义一个标识为datas
     * 如果要设定相应的样式,可以在该行使用styles完成设定,此时所有此行都使用该样式
     * 如果使用defaultStyls作为表示,表示默认样式,如果没有defaultStyles使用datas行作为默认样式
     * Created by 钟述林 393156105@qq.com on 2016/10/28 23:38.
     */
    public class ExcelTemplate {
    
        /**
         * 数据行标识
         */
        public final static String DATA_LINE = "datas";
        /**
         * 默认样式标识
         */
        public final static String DEFAULT_STYLE = "defaultStyles";
        /**
         * 行样式标识
         */
        public final static String STYLE = "styles";
        /**
         * 插入序号样式标识
         */
        public final static String SER_NUM = "sernums";
        private static ExcelTemplate et = new ExcelTemplate();
        private Workbook wb;
        private Sheet sheet;
        /**
         * 数据的初始化列数
         */
        private int initColIndex;
        /**
         * 数据的初始化行数
         */
        private int initRowIndex;
        /**
         * 当前列数
         */
        private int curColIndex;
        /**
         * 当前行数
         */
        private int curRowIndex;
        /**
         * 当前行对象
         */
        private Row curRow;
        /**
         * 最后一行的数据
         */
        private int lastRowIndex;
        /**
         * 默认样式
         */
        private CellStyle defaultStyle;
        /**
         * 默认行高
         */
        private float rowHeight;
        /**
         * 存储某一方所对于的样式
         */
        private Map<Integer,CellStyle> styles;
        /**
         * 序号的列
         */
        private int serColIndex;
        private ExcelTemplate(){
    
        }
        public static ExcelTemplate getInstance() {
            return et;
        }
    
        /**
         * 从classpath路径下读取相应的模板文件
         * @param path
         * @return
         */
        public ExcelTemplate readTemplateByClasspath(String path) {
            try {
                wb = new HSSFWorkbook(TemplateFileUtil.getTemplates(path));
                initTemplate();
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException("读取模板不存在!请检查");
            }
            return this;
        }
        /**
         * 将文件写到相应的路径下
         * @param filepath
         */
        public void writeToFile(String filepath) {
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(filepath);
                wb.write(fos);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
                throw new RuntimeException("写入的文件不存在");
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException("写入数据失败:"+e.getMessage());
            } finally {
                try {
                    if(fos!=null) fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        /**
         * 将文件写到某个输出流中
         * @param os
         */
        public void wirteToStream(OutputStream os) {
            try {
                wb.write(os);
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException("写入流失败:"+e.getMessage());
            }
        }
        /**
         * 从某个路径来读取模板
         * @param path
         * @return
         */
        public ExcelTemplate readTemplateByPath(String path) {
            try {
                wb = new HSSFWorkbook(TemplateFileUtil.getTemplates(path));
                initTemplate();
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException("读取模板不存在!请检查");
            }
            return this;
        }
    
        /**
         * 创建相应的元素,基于String类型
         * @param value
         */
        public void createCell(String value) {
            Cell c = curRow.createCell(curColIndex);
            setCellStyle(c);
            c.setCellValue(value);
            curColIndex++;
        }
        public void createCell(int value) {
            Cell c = curRow.createCell(curColIndex);
            setCellStyle(c);
            c.setCellValue((int)value);
            curColIndex++;
        }
        public void createCell(Date value) {
            Cell c = curRow.createCell(curColIndex);
            setCellStyle(c);
            c.setCellValue(value);
            curColIndex++;
        }
        public void createCell(double value) {
            Cell c = curRow.createCell(curColIndex);
            setCellStyle(c);
            c.setCellValue(value);
            curColIndex++;
        }
        public void createCell(boolean value) {
            Cell c = curRow.createCell(curColIndex);
            setCellStyle(c);
            c.setCellValue(value);
            curColIndex++;
        }
    
        public void createCell(Calendar value) {
            Cell c = curRow.createCell(curColIndex);
            setCellStyle(c);
            c.setCellValue(value);
            curColIndex++;
        }
        public void createCell(BigInteger value) {
            Cell c = curRow.createCell(curColIndex);
            setCellStyle(c);
            c.setCellValue(value==null?0:value.intValue());
            curColIndex++;
        }
        /**
         * 设置某个元素的样式
         * @param c
         */
        private void setCellStyle(Cell c) {
            if(styles.containsKey(curColIndex)) {
                c.setCellStyle(styles.get(curColIndex));
            } else {
                c.setCellStyle(defaultStyle);
            }
        }
        /**
         * 创建新行,在使用时只要添加完一行,需要调用该方法创建
         */
        public void createNewRow() {
            if(lastRowIndex>curRowIndex&&curRowIndex!=initRowIndex) {
                sheet.shiftRows(curRowIndex, lastRowIndex, 1,true,true);
                lastRowIndex++;
            }
            curRow = sheet.createRow(curRowIndex);
            curRow.setHeightInPoints(rowHeight);
            curRowIndex++;
            curColIndex = initColIndex;
        }
    
        /**
         * 插入序号,会自动找相应的序号标示的位置完成插入
         */
        public void insertSer() {
            int index = 1;
            Row row = null;
            Cell c = null;
            for(int i=initRowIndex;i<curRowIndex;i++) {
                row = sheet.getRow(i);
                c = row.createCell(serColIndex);
                setCellStyle(c);
                c.setCellValue(index++);
            }
        }
        /**
         * 根据map替换相应的常量,通过Map中的值来替换#开头的值
         * @param datas
         */
        public void replaceFinalData(Map<String,String> datas) {
            if(datas==null) return;
            for(Row row:sheet) {
                for(Cell c:row) {
    //                if(c.getCellType()!=Cell.CELL_TYPE_STRING) continue;
                    String str = c.getStringCellValue().trim();
                    if(str.startsWith("#")) {
                        if(datas.containsKey(str.substring(1))) {
                            c.setCellValue(datas.get(str.substring(1)));
                        }
                    }
                }
            }
        }
        /**
         * 基于Properties的替换,依然也是替换#开始的
         * @param prop
         */
        public void replaceFinalData(Properties prop) {
            if(prop==null) return;
            for(Row row:sheet) {
                for(Cell c:row) {
    //                if(c.getCellType()!=Cell.CELL_TYPE_STRING) continue;
                    String str = c.getStringCellValue().trim();
                    if(str.startsWith("#")) {
                        if(prop.containsKey(str.substring(1))) {
                            c.setCellValue(prop.getProperty(str.substring(1)));
                        }
                    }
                }
            }
        }
    
        private void initTemplate() {
            sheet = wb.getSheetAt(0);
            initConfigData();
            lastRowIndex = sheet.getLastRowNum();
            curRow = sheet.createRow(curRowIndex);
        }
        /**
         * 初始化数据信息
         */
        private void initConfigData() {
            boolean findData = false;
            boolean findSer = false;
            for(Row row:sheet) {
                if(findData) break;
                for(Cell c:row) {
    //                if(c.getCellType()!=Cell.CELL_TYPE_STRING) continue;
                    String str = c.getStringCellValue().trim();
                    if(str.equals(SER_NUM)) {
                        serColIndex = c.getColumnIndex();
                        findSer = true;
                    }
                    if(str.equals(DATA_LINE)) {
                        initColIndex = c.getColumnIndex();
                        initRowIndex = row.getRowNum();
                        curColIndex = initColIndex;
                        curRowIndex = initRowIndex;
                        findData = true;
                        defaultStyle = c.getCellStyle();
                        rowHeight = row.getHeightInPoints();
                        initStyles();
                        break;
                    }
                }
            }
            if(!findSer) {
                initSer();
            }
        }
        /**
         * 初始化序号位置
         */
        private void initSer() {
            for(Row row:sheet) {
                for(Cell c:row) {
    //                if(c.getCellType()!=Cell.CELL_TYPE_STRING) continue;
                    String str = c.getStringCellValue().trim();
                    if(str.equals(SER_NUM)) {
                        serColIndex = c.getColumnIndex();
                    }
                }
            }
        }
        /**
         * 初始化样式信息
         */
        private void initStyles() {
            styles = new HashMap<Integer, CellStyle>();
            for(Row row:sheet) {
                for(Cell c:row) {
    //                if(c.getCellType()!=Cell.CELL_TYPE_STRING) continue;
                    String str = c.getStringCellValue().trim();
                    if(str.equals(DEFAULT_STYLE)) {
                        defaultStyle = c.getCellStyle();
                    }
                    if(str.equals(STYLE)) {
                        styles.put(c.getColumnIndex(), c.getCellStyle());
                    }
                }
            }
        }
    }
    • 操作工具类
    /**
     * 该类实现了将一组对象转换为Excel表格,并且可以从Excel表格中读取到一组List对象中
     * 该类利用了BeanUtils框架中的反射完成
     * 使用该类的前提,在相应的实体对象上通过ExcelReources来完成相应的注解
     * Created by 钟述林 393156105@qq.com on 2016/10/29 0:15.
     */
    public class ExcelUtil {
        private static ExcelUtil eu = new ExcelUtil();
        private ExcelUtil(){}
    
        public static ExcelUtil getInstance() {
            return eu;
        }
        /**
         * 处理对象转换为Excel
         * @param template
         * @param objs
         * @param clz
         * @param isClasspath
         * @return
         */
        private ExcelTemplate handlerObj2Excel (String template, List objs, Class clz, boolean isClasspath)  {
            ExcelTemplate et = ExcelTemplate.getInstance();
            try {
                if(isClasspath) {
                    et.readTemplateByClasspath(template);
                } else {
                    et.readTemplateByPath(template);
                }
                List<ExcelHeader> headers = getHeaderList(clz);
                Collections.sort(headers);
                //输出标题
                et.createNewRow();
                for(ExcelHeader eh:headers) {
                    et.createCell(eh.getTitle());
                }
                //输出值
                for(Object obj:objs) {
                    et.createNewRow();
                    for(ExcelHeader eh:headers) {
                        //              Method m = clz.getDeclaredMethod(mn);
                        //              Object rel = m.invoke(obj);
                        et.createCell(BeanUtils.getProperty(obj,getMethodName(eh)));
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
            return et;
        }
        /**
         * 根据标题获取相应的方法名称
         * @param eh
         * @return
         */
        private String getMethodName(ExcelHeader eh) {
            String mn = eh.getMethodName().substring(3);
            mn = mn.substring(0,1).toLowerCase()+mn.substring(1);
            return mn;
        }
        /**
         * 将对象转换为Excel并且导出,该方法是基于模板的导出,导出到流
         * @param datas 模板中的替换的常量数据
         * @param template 模板路径
         * @param os 输出流
         * @param objs 对象列表
         * @param clz 对象的类型
         * @param isClasspath 模板是否在classPath路径下
         */
        public void exportObj2ExcelByTemplate(Map<String,String> datas, String template, OutputStream os, List objs, Class clz, boolean isClasspath) {
            try {
                ExcelTemplate et = handlerObj2Excel(template, objs, clz, isClasspath);
                et.replaceFinalData(datas);
                et.wirteToStream(os);
                os.flush();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /**
         * 将对象转换为Excel并且导出,该方法是基于模板的导出,导出到一个具体的路径中
         * @param datas 模板中的替换的常量数据
         * @param template 模板路径
         * @param outPath 输出路径
         * @param objs 对象列表
         * @param clz 对象的类型
         * @param isClasspath 模板是否在classPath路径下
         */
        public void exportObj2ExcelByTemplate(Map<String,String> datas,String template,String outPath,List objs,Class clz,boolean isClasspath) {
            ExcelTemplate et = handlerObj2Excel(template, objs, clz, isClasspath);
            et.replaceFinalData(datas);
            et.writeToFile(outPath);
        }
    
        /**
         * 将对象转换为Excel并且导出,该方法是基于模板的导出,导出到流,基于Properties作为常量数据
         * @param prop 基于Properties的常量数据模型
         * @param template 模板路径
         * @param os 输出流
         * @param objs 对象列表
         * @param clz 对象的类型
         * @param isClasspath 模板是否在classPath路径下
         */
        public void exportObj2ExcelByTemplate(Properties prop, String template, OutputStream os, List objs, Class clz, boolean isClasspath) {
            ExcelTemplate et = handlerObj2Excel(template, objs, clz, isClasspath);
            et.replaceFinalData(prop);
            et.wirteToStream(os);
        }
        /**
         * 将对象转换为Excel并且导出,该方法是基于模板的导出,导出到一个具体的路径中,基于Properties作为常量数据
         * @param prop 基于Properties的常量数据模型
         * @param template 模板路径
         * @param outPath 输出路径
         * @param objs 对象列表
         * @param clz 对象的类型
         * @param isClasspath 模板是否在classPath路径下
         */
        public void exportObj2ExcelByTemplate(Properties prop,String template,String outPath,List objs,Class clz,boolean isClasspath) {
            ExcelTemplate et = handlerObj2Excel(template, objs, clz, isClasspath);
            et.replaceFinalData(prop);
            et.writeToFile(outPath);
        }
    
        private Workbook handleObj2Excel(List objs, Class clz) {
            Workbook wb = new HSSFWorkbook();
            try {
                Sheet sheet = wb.createSheet();
                Row r = sheet.createRow(0);
                List<ExcelHeader> headers = getHeaderList(clz);
                Collections.sort(headers);
                //写标题
                for(int i=0;i<headers.size();i++) {
                    r.createCell(i).setCellValue(headers.get(i).getTitle());
                }
                //写数据
                Object obj = null;
                for(int i=0;i<objs.size();i++) {
                    r = sheet.createRow(i+1);
                    obj = objs.get(i);
                    for(int j=0;j<headers.size();j++) {
                        r.createCell(j).setCellValue(BeanUtils.getProperty(obj, getMethodName(headers.get(j))));
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
            return wb;
        }
        /**
         * 导出对象到Excel,不是基于模板的,直接新建一个Excel完成导出,基于路径的导出
         * @param outPath 导出路径
         * @param objs 对象列表
         * @param clz 对象类型
         */
        public void exportObj2Excel(String outPath,List objs,Class clz) {
            Workbook wb = handleObj2Excel(objs, clz);
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(outPath);
                wb.write(fos);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if(fos!=null) fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        /**
         * 导出对象到Excel,不是基于模板的,直接新建一个Excel完成导出,基于流
         * @param os 输出流
         * @param objs 对象列表
         * @param clz 对象类型
         */
        public void exportObj2Excel(OutputStream os,List objs,Class clz) {
            try {
                Workbook wb = handleObj2Excel(objs, clz);
                wb.write(os);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /**
         * 从类路径读取相应的Excel文件到对象列表
         * @param path 类路径下的path
         * @param clz 对象类型
         * @param readLine 开始行,注意是标题所在行
         * @param tailLine 底部有多少行,在读入对象时,会减去这些行
         * @return
         */
        public List<Object> readExcel2ObjsByClasspath(String path,Class clz,int readLine,int tailLine) {
            Workbook wb = null;
            try {
                wb = new HSSFWorkbook(TemplateFileUtil.getTemplates(path));
                return handlerExcel2Objs(wb, clz, readLine,tailLine);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        /**
         * 从文件路径读取相应的Excel文件到对象列表
         * @param path 文件路径下的path
         * @param clz 对象类型
         * @param readLine 开始行,注意是标题所在行
         * @param tailLine 底部有多少行,在读入对象时,会减去这些行
         * @return
         */
        public List<Object> readExcel2ObjsByPath(String path,Class clz,int readLine,int tailLine) {
            Workbook wb = null;
            try {
                wb = new HSSFWorkbook(TemplateFileUtil.getTemplates(path));
                return handlerExcel2Objs(wb, clz, readLine,tailLine);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        /**
         * 从类路径读取相应的Excel文件到对象列表,标题行为0,没有尾行
         * @param path 路径
         * @param clz 类型
         * @return 对象列表
         */
        public List<Object> readExcel2ObjsByClasspath(String path,Class clz) {
            return this.readExcel2ObjsByClasspath(path, clz, 0,0);
        }
        /**
         * 从文件路径读取相应的Excel文件到对象列表,标题行为0,没有尾行
         * @param path 路径
         * @param clz 类型
         * @return 对象列表
         */
        public List<Object> readExcel2ObjsByPath(String path,Class clz) {
            return this.readExcel2ObjsByPath(path, clz,0,0);
        }
    
        private String getCellValue(Cell c) {
            String o = null;
            switch (c.getCellType()) {
                case Cell.CELL_TYPE_BLANK:
                    o = ""; break;
                case Cell.CELL_TYPE_BOOLEAN:
                    o = String.valueOf(c.getBooleanCellValue()); break;
                case Cell.CELL_TYPE_FORMULA:
                    o = String.valueOf(c.getCellFormula()); break;
                case Cell.CELL_TYPE_NUMERIC:
                    o = String.valueOf(c.getNumericCellValue()); break;
                case Cell.CELL_TYPE_STRING:
                    o = c.getStringCellValue(); break;
                default:
                    o = null;
                    break;
            }
            return o;
        }
    
        private List<Object> handlerExcel2Objs(Workbook wb,Class clz,int readLine,int tailLine) {
            Sheet sheet = wb.getSheetAt(0);
            List<Object> objs = null;
            try {
                Row row = sheet.getRow(readLine);
                objs = new ArrayList<Object>();
                Map<Integer,String> maps = getHeaderMap(row, clz);
                if(maps==null||maps.size()<=0) throw new RuntimeException("要读取的Excel的格式不正确,检查是否设定了合适的行");
                for(int i=readLine+1;i<=sheet.getLastRowNum()-tailLine;i++) {
                    row = sheet.getRow(i);
                    Object obj = clz.newInstance();
                    for(Cell c:row) {
                        int ci = c.getColumnIndex();
                        String mn = maps.get(ci).substring(3);
                        mn = mn.substring(0,1).toLowerCase()+mn.substring(1);
                        BeanUtils.copyProperty(obj,mn, this.getCellValue(c));
                    }
                    objs.add(obj);
                }
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            return objs;
        }
    
        private List<ExcelHeader> getHeaderList(Class clz) {
            List<ExcelHeader> headers = new ArrayList<ExcelHeader>();
            Method[] ms = clz.getDeclaredMethods();
            for(Method m:ms) {
                String mn = m.getName();
                if(mn.startsWith("get")) {
                    if(m.isAnnotationPresent(ExcelResources.class)) {
                        ExcelResources er = m.getAnnotation(ExcelResources.class);
                        headers.add(new ExcelHeader(er.title(),er.order(),mn));
                    }
                }
            }
            return headers;
        }
    
        private Map<Integer,String> getHeaderMap(Row titleRow,Class clz) {
            List<ExcelHeader> headers = getHeaderList(clz);
            Map<Integer,String> maps = new HashMap<Integer, String>();
            for(Cell c:titleRow) {
                String title = c.getStringCellValue();
                for(ExcelHeader eh:headers) {
                    if(eh.getTitle().equals(title.trim())) {
                        maps.put(c.getColumnIndex(), eh.getMethodName().replace("get","set"));
                        break;
                    }
                }
            }
            return maps;
        }
    }
    • Excel模板文件

    创建一个模板文件,如下图:

    POI导出Excel的模板文件

    • 测试类
    @SpringBootTest
    @RunWith(SpringRunner.class)
    public class ExportExcelTest {
    
        @Test
        public void test() throws Exception {
            List<WebDto> list = new ArrayList<WebDto>();
            list.add(new WebDto("知识林", "http://www.zslin.com", "admin", "111111", 555));
            list.add(new WebDto("权限系统", "http://basic.zslin.com", "admin", "111111", 111));
            list.add(new WebDto("校园网", "http://school.zslin.com", "admin", "222222", 333));
    
            Map<String, String> map = new HashMap<String, String>();
            map.put("title", "网站信息表");
            map.put("total", list.size()+" 条");
            map.put("date", getDate());
    
            ExcelUtil.getInstance().exportObj2ExcelByTemplate(map, "web-info-template.xls", new FileOutputStream("D:/temp/out.xls"),
                    list, WebDto.class, true);
        }
    
        private String getDate() {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
            return sdf.format(new Date());
        }
    }

    执行测试方法后,查看D:/temp/out.xls文件后可以看到如下图的内容:

    POI导出Excel结果图

    示例代码:https://github.com/zsl131/spring-boot-test/tree/master/study16

    本文章来自【知识林】

    展开全文
  • springboot poi导出Excel

    2019-12-28 16:13:35
    什么是poi? poi是阿帕奇组件开源的poi项目,以基于Office Open XML标准(OOXML)和Microsoft的OLE 2复合文档...下面我们就来从mysql中导出一个Excel。 第一步:创建数据库和表并且插入数据 第二步:导入maven依赖 ...

    什么是poi?

    poi是阿帕奇组件开源的poi项目,以基于Office Open XML标准(OOXML)和Microsoft的OLE 2复合文档格式(OLE2)来处理各种文件格式。Apache POI api的主要用途是用于文本提取应用程序,例如网络蜘蛛,索引构建器和内容管理系统。下面我们就来从mysql中导出一个Excel。

    第一步:创建数据库和表并且插入数据

    在这里插入图片描述
    在这里插入图片描述

    第二步:导入maven依赖

    <!-- poi -->
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi</artifactId>
                <version>4.1.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi-ooxml</artifactId>
                <version>4.1.0</version>
            </dependency>
    
            <!--mysql-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.21</version>
            </dependency>
    

    因为Excle有03版和07版,也就是xls和xlsx这两个版本所以我们分别导入各自的poi依赖。

    第三步:把需要导出到Excel的表返回List集合

    总体结构
    在这里插入图片描述

    pojo

    package com.example.demo.pojo;
    
    public class Student {
    
        private int id;
    
        private String name;
    
        private int age;
    
        private String phone;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    }
    
    
    

    dao

    package com.example.demo.dao;
    
    import com.example.demo.pojo.Student;
    import org.apache.ibatis.annotations.Mapper;
    import java.util.List;
    @Mapper
    public interface StudentMapper {
    
        List<Student> findAll();
    }
    
    

    *.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.example.demo.dao.StudentMapper">
        <select id="findAll" resultType="com.example.demo.pojo.Student">
            SELECT * FROM student
        </select>
    </mapper>
    

    service

    package com.example.demo.service;
    
    import com.example.demo.pojo.Student;
    
            import java.util.List;
    
    public interface StudentService {
        List<Student> findAll();
    }
    
    

    Impl

    package com.example.demo.service.Impl;
    
    import com.example.demo.dao.StudentMapper;
    import com.example.demo.pojo.Student;
    import com.example.demo.service.StudentService;
    import org.springframework.stereotype.Service;
    import javax.annotation.Resource;
    import java.util.List;
    
    @Service
    public class StudentServiceImpl implements StudentService{
    
        @Resource
        private StudentMapper studentMapper;
    
        @Override
        public List<Student> findAll() {
            return studentMapper.findAll();
        }
    }
    
    

    util

    package com.example.demo.util;
    
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServletResponse;
    import java.io.*;
    
    public class ExcelUtil {
        public static void createFile(HttpServletResponse response, HSSFWorkbook workbook) {
    
            //设置文件名
            String fileName = "学生信息";
    
            try {
                //捕获内存缓冲区的数据,装换成字符数组
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                workbook.write(out);
                // 获取内存缓冲中的数据
                byte[] content = out.toByteArray();
                // 将字节数组转化为输入流
                InputStream in = new ByteArrayInputStream(content);
                //通过调用reset()方法可以重新定位。
                response.reset();
                // 如果文件名是英文名不需要加编码格式,如果是中文名需要添加"iso-8859-1"防止乱码
                response.setHeader("Content-Disposition", "attachment; filename=" + new String((fileName + ".xls").getBytes(), "iso-8859-1"));
                response.addHeader("Content-Length", "" + content.length);
                response.setContentType("application/vnd.ms-excel;charset=UTF-8");
                ServletOutputStream outputStream = response.getOutputStream();
                BufferedInputStream bis = new BufferedInputStream(in);
                BufferedOutputStream bos = new BufferedOutputStream(outputStream);
                byte[] buff = new byte[8192];
                int bytesRead;
                while (-1 != (bytesRead = bis.read(buff, 0, buff.length))) {
                    bos.write(buff, 0, bytesRead);
                }
                bis.close();
                bos.close();
                outputStream.flush();
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    }
    
    

    controller

    package com.example.demo.controller;
    
    import com.example.demo.pojo.Student;
    import com.example.demo.service.StudentService;
    import com.example.demo.util.ExcelUtil;
    import org.apache.poi.hssf.usermodel.*;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.List;
    
    @Controller
    public class StudentController {
    
        @Resource
        private StudentService studentService;
        
        @RequestMapping("/exportExcle")
        public void exportExcle(HttpServletRequest request, HttpServletResponse response){
            List<Student> list=studentService.findAll();
            //创建工作薄
            HSSFWorkbook workbook=new HSSFWorkbook();
            //创建表
            HSSFSheet sheet=workbook.createSheet("学生信息");
            //创建行
            HSSFRow row=sheet.createRow(0);
            //创建单元格式
            HSSFCellStyle cellStyle=workbook.createCellStyle();
            //表头
            String[] head={"序号","姓名","年龄","手机号码"};
            HSSFCell cell;
            //设置表头
            for(int iHead=0;iHead<head.length;iHead++){
                 cell=row.createCell(iHead);
                 cell.setCellValue(head[iHead]);
                 cell.setCellStyle(cellStyle);
            }
    
            //设置表格内容
            for (int iBody=0;iBody<list.size();iBody++){
                row=sheet.createRow(iBody+1);
                Student student=list.get(iBody);
                String[] studentArray =new String[4];
                studentArray[0]= String.valueOf(student.getId());
                studentArray[1]=student.getName()+ "";
                studentArray[2]=student.getAge() + "";
                studentArray[3]=student.getPhone()+ "";
                for(int iArray=0; iArray<studentArray.length; iArray++) {
                    row.createCell(iArray).setCellValue(studentArray[iArray]);
                }
    
            }
            // 生成Excel文件
            ExcelUtil.createFile(response, workbook);
        }
    }
    
    

    导出Excel效果图

    启动项目之后,在浏览器输入http://localhost:8080/exportExcel就可以进入,帮你导出Excel

    在这里插入图片描述
    然后打开Excel查看
    在这里插入图片描述
    这样就完成了Excel的导出,需要深入了解可以前往官网地址

    展开全文
  • --读取excel文件,配置POI框架的依赖--> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.17</version&...
  • Springboot整合Poi导出excel(简单版)

    万次阅读 热门讨论 2019-05-03 10:56:40
    总所周知Springboot是一个功能强大的微服务框架,集成了很多优秀的Spring组件,但是却没有支持Excel导出的插件。为此我们引入Poi插件。场景是导出Controller返回的Json数据,输出到二维表格。设置表头及其他设置可...
  • 再分享一种excel导出 这种是需要反射获取实体类的get方法类实现动态获取值 依赖 <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId> &...
  • 最近在做 Excel 导出的时候,需要导出固定格式的excel,比如订单格式,如下所示 需要往里面填充公司信息 客户信息 和订单信息,完成后的excel如下 这里金额合计 大写 小写 是excel自动计算的 ,首先需要的...
  • 本文是vhr系列的第十一篇,vhr项目地址https://github.com/lenve/vhr 导出Excel整体来说,Excel有.xls和.xlsx,那么在POI中这两个也对应两个不同的类,但是类名不同,方法基本都是一致的,因此我这里将只介绍.xls一...
  • 后台管理系统经常会用到表格来展示数据,如用户基本信息,若管理员需要将用户信息保存到本地,则需要对用户信息进行导出导出的文件大多采用excel。 java中对于excel的读写可以采用POI 一、POI简介 Apache POI是...
  • 6.创建easypoi导入导出工具类 package com.lsc.utils; import cn.afterturn.easypoi.excel.ExcelExportUtil; import cn.afterturn.easypoi.excel.ExcelImportUtil; import ...
  • 这里导入两个poi的原因是:在excel的表格保存为xls和xlsx两种格式,excel表格早先是xls后来又加入了xlsx的格式,在下面的代码中会有所体现。 2.编写demo @RestController @RequestMapping("/POI") public class ...
  • SpringBoot中POI 导入 导出

    千次阅读 2019-03-26 14:58:18
    1 、导出数据----将数据库中的数据进行备份 2 、导入数据----将excel中的数据批量导入数据库 基于maven坐标导入POI支持 <!-- excel2003使用的包 --> <dependency> <groupId>...
  • 最近项目需求中有需要导出Execl表格的要求,而且还是大量的数据,于是把之前的整理了一下,抽成了一个统一的工具类,需要时直接调用工具类即可,代码如下: 一、先看下效果 二、 导入依赖 <properties>...
  • 本编文章主要写了如何通过POI获取Excel表格(含合并单元格)的数据,可以获取任意sheet表中的数据,然后返回list<String[]>形式的数据,根据自己的需求处理数据 /** *现在传的是MultipartFile ,可以自行修改成...
  • 要做一个前端上传Excel文件,后端接收到后读取Excel文件数据后保存到Mysql的功能。 非常感谢这位博主的https://blog.csdn.net/phil_jing/article/details/78307819,虽然完全复制上去有报错,但是问题不大。 主要...
  • 上篇文章已经介绍Excel可以分为Excel2003和Excel2007两种版本,Excel2003在POI中使用HSSF对象,一个sheet最多允许65536条数据,处理较少数据时可以使用,但是处理百万数据时Excel2003肯定容纳不了;Excel2007在POI中...
  • 【springboot系列】springboot接入poi

    千次阅读 2019-05-07 16:05:56
    springboot接入poi 文章目录springboot接入poi一、POI是什么二、POI的简单使用三、代码如下:1、引入依赖2、写一个Service接口3、实现功能4、工具类5、功能测试 一、POI是什么 ...Springboot+用poi实现Excel...
  • 项目中使用到了导入导出的功能所以自己写了一个关于POI的工具类和demo,希望能帮到会使用到的朋友。对比了很多市面上的方法,最后还是选择了easyExcel,也把easyExcel的demo也写了,文章底部会有相关跳转连接。 2....
  • Springboot集成POI

    千次阅读 2019-08-13 11:41:03
    //创建一个Excel表单,参数为sheet的名字 HSSFSheet sheet = workbook . createSheet ( "sheet" ) ; //设置表头 setTitle ( workbook , sheet , clazz ) ; //设置单元格并赋值 setData ( sheet , ...

空空如也

空空如也

1
收藏数 20
精华内容 8
关键字:

springbootpoi导出excel

spring 订阅