导出execl

已于 2023-11-08 11:09:26 修改
阅读量87 收藏
点赞数
文章标签： java servlet 前端
于 2022-11-15 11:08:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37555514/article/details/127862127
版权

web下pom.xml

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

全局pom.xml

 <poi.version>3.10-FINAL</poi.version>
 
 <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi</artifactId>
                <version>${poi.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi-ooxml</artifactId>
                <version>${poi.version}</version>
            </dependency>

类位置
在这里插入图片描述
ExporterFactory

package com.opensesame.tms.platform.exporter;


import com.opensesame.tms.platform.exporter.head.ExporterHead;
import com.opensesame.tms.platform.exporter.template.AbstractExporterTemplate;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * 导出工厂
 * @author sonny
 */
public class ExporterFactory {

	protected Map<Class<? extends AbstractExporterTemplate>, ? extends AbstractExporterTemplate> exporterTemplate;

	private static final String EXCEL_FILENAME_EXTENSION = ".xlsx";

	/**
	 * 导出excel
	 * 
	 * @param response 响应流
	 * @param map 文件名 和 数据映射
	 * @param exporterHead 导出文件头
	 * @param et 导出模板
	 * @param args
	 * @throws IOException
	 * @throws InvalidFormatException
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void process(HttpServletResponse response, List<? extends LinkedHashMap> data, ExporterHead exporterHead, Class<? extends AbstractExporterTemplate> et, Object... args)
			throws IOException, InvalidFormatException {
		AbstractExporterTemplate abstractExporterTemplate = exporterTemplate.get(et);
		Workbook workBook = null;
		workBook = new XSSFWorkbook();

		CellStyle cellStyle = getCellStyle(workBook);
		Sheet sheet = workBook.createSheet();
		// 设置表头
		abstractExporterTemplate.drawHead(workBook , sheet, exporterHead ,cellStyle,  args);
		int startRow = abstractExporterTemplate.getStartRowNumber();
		// 写入业务数据
		for (LinkedHashMap<String, String> temp : data) {
			Row row = (Row) sheet.createRow(startRow++);
			int rowNum = 0;
			for (String value : temp.values()) {
				Cell cell = row.createCell(rowNum++);
				cell.setCellStyle(cellStyle);
				cell.setCellValue(value);
			}
		}
		// 收尾工作
		abstractExporterTemplate.windup(workBook, sheet, exporterHead, cellStyle, args);
		// 设置响应头
		setResponseHead(response, getFileName(abstractExporterTemplate, exporterHead));
		// 输出
		ServletOutputStream out = response.getOutputStream();
		workBook.write(out);
		out.close();
		out.flush();
	}

	/**
	 * 获取单元格样式
	 * 
	 * @param workBook
	 * @return
	 */
	public static CellStyle getCellStyle(Workbook workBook) {
		CellStyle style = workBook.createCellStyle();
		style.setBorderBottom(XSSFCellStyle.BORDER_THIN);
		style.setBorderTop(XSSFCellStyle.BORDER_THIN);
		style.setBorderRight(XSSFCellStyle.BORDER_THIN);
		style.setBorderLeft(XSSFCellStyle.BORDER_THIN);
		Font font = workBook.createFont();
		font.setFontName("Calibri");    
		font.setFontHeightInPoints((short) 12);   
		style.setFont(font);
		return style;
	}
	
	/**
	 * 获取文件名称
	 * 
	 * @param abstractExporterTemplate
	 * @param exporterHead
	 * @return
	 */
	public static String getFileName(AbstractExporterTemplate abstractExporterTemplate, ExporterHead exporterHead) {
		if (null != exporterHead && StringUtils.isNotEmpty(exporterHead.getFileName())) {
			return exporterHead.getFileName();
		}
		if (null != exporterHead && StringUtils.isNotEmpty(exporterHead.getTitle())) {
			return exporterHead.getTitle();
		}
		return abstractExporterTemplate.getDefaultFileName();
	}

	/**
	 * 设置响应头信息
	 * 
	 * @param response
	 * @param fileName
	 * @throws UnsupportedEncodingException
	 */
	public static void setResponseHead(HttpServletResponse response, String fileName) throws UnsupportedEncodingException {
		response.setCharacterEncoding("UTF-8");
		response.setHeader("Pragma", "no-cache");
		response.setHeader("Cache-Control", "no-cache");
		response.setDateHeader("Expires", 0);
		response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
			//解决文件名中文乱码
		fileName = URLEncoder.encode(fileName, "UTF-8");
		response.setHeader("Content-Disposition", "attachment;fileName=\"" + new String(fileName.getBytes("utf-8"), "ISO8859-1") + EXCEL_FILENAME_EXTENSION + "\"");
	}

	public Map<Class<? extends AbstractExporterTemplate>, ? extends AbstractExporterTemplate> getExporterTemplate() {
		return exporterTemplate;
	}

	public void setExporterTemplate(Map<Class<? extends AbstractExporterTemplate>, ? extends AbstractExporterTemplate> exporterTemplate) {
		this.exporterTemplate = exporterTemplate;
	}

}

ExporterTemplate

package com.opensesame.tms.platform.exporter.template;


import com.opensesame.tms.platform.exporter.head.ExporterHead;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;

public interface ExporterTemplate {

	// 设置表头信息
	void drawHead(Workbook workBook, Sheet sheet, ExporterHead exporterHead, CellStyle cellStyle, Object... args);

	// 画完表格清理工作
	void windup(Workbook workBook, Sheet sheet, ExporterHead exporterHead, CellStyle cellStyle, Object... args);

}

AbstractExporterTemplate

package com.opensesame.tms.platform.exporter.template;

import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;

public abstract class AbstractExporterTemplate implements ExporterTemplate {

	int startRowNumber = 0;

	String defaultFileName = "导出数据";

	String templateFilePath = "";

	public int getStartRowNumber() {
		return startRowNumber;
	}

	public void setStartRowNumber(int startRowNumber) {
		this.startRowNumber = startRowNumber;
	}

	public String getDefaultFileName() {
		return defaultFileName;
	}

	public void setDefaultFileName(String defaultFileName) {
		this.defaultFileName = defaultFileName;
	}

	public String getTemplateFilePath() {
		return templateFilePath;
	}

	public void setTemplateFilePath(String templateFilePath) {
		this.templateFilePath = templateFilePath;
	}

	/**
	 * 获取单元格样式
	 *
	 * @param workBook
	 * @return
	 */
	public static CellStyle getDateCellStyle(Workbook workBook) {

		CellStyle style = workBook.createCellStyle();
		style.setAlignment(CellStyle.ALIGN_CENTER);
		Font font = workBook.createFont();
		font.setFontName("Calibri");
		font.setFontHeightInPoints((short) 12);
		style.setFont(font);
		return style;
	}
	/**
	 * 获取单元格样式没有边框
	 *
	 * @param workBook
	 * @return
	 */
	public static CellStyle getTitleCellStyle(Workbook workBook) {
		CellStyle style = workBook.createCellStyle();
		style.setAlignment(CellStyle.ALIGN_CENTER);
		style.setBorderBottom(XSSFCellStyle.BORDER_NONE);
		style.setBorderTop(XSSFCellStyle.BORDER_NONE);
		style.setBorderRight(XSSFCellStyle.BORDER_NONE);
		style.setBorderLeft(XSSFCellStyle.BORDER_NONE);
		Font font = workBook.createFont();
		font.setFontName("Calibri");
		font.setFontHeightInPoints((short) 12);
		style.setFont(font);
		return style;
	}
}

ExporterHead

package com.opensesame.tms.platform.exporter.head;

import java.io.Serializable;

public class ExporterHead implements Serializable {
	private static final long serialVersionUID = 1L;

	public ExporterHead() {
		super();
	}
	
	public ExporterHead(String title) {
		super();
		this.title = title;
	}
	
	public ExporterHead(String fileName, String title) {
		super();
		this.fileName = fileName;
		this.title = title;
	}

	// 文件名
	String fileName;
	// 标题
	String title;
	
	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getFileName() {
		return fileName;
	}

	public void setFileName(String fileName) {
		this.fileName = fileName;
	}

}

Controller

 /**
     * 导出参考价设置
     *
     * @return
     * @throws IOException
     * @throws InvalidFormatException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
     //用post原因，输入的查询参数太长了
    @RequestMapping(value = "/exportPrice", method = {RequestMethod.POST})
    @ResponseBody
    @ApiOperation(value = "导出参考价设置", notes = "导出参考价设置", response = String.class)
    public void exportinsurance(HttpServletResponse response,
                                @ApiParam(value = "发货机构") @RequestParam(required = false) List<Long> deliveryOrgIds,
                                @ApiParam(value = "到货机构") @RequestParam(required = false) List<Long> receiveOrgIds,
                                @ApiParam(value = "状态：1有效、2无效") @RequestParam(required = true) Integer validStatus)
            throws IOException, InvalidFormatException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        List<LinkedHashMap> result = new LinkedList<>();
        List<ConfigReferencePriceDto> exportList = configReferencePriceService.findExportList(deliveryOrgIds, receiveOrgIds, validStatus);
        String[] cols = {"deliveryOrgId", "receiveOrgId", "unitVolumePrice", "unitWeightPrice", "thresholdVolume", "thresholdVolumePrice", "thresholdWeight", "thresholdWeightPrice", "singlePiecePrice",
                "abnormityCoefficient", "equipmentCoefficient", "status", "updateTime"
        };
        List<Organization> organizationList = organizationService.findByNamedParamList(null);
        List<String> columns = new ArrayList<>();
        for (String s : cols) {
            columns.add(s);
        }
        for (ConfigReferencePriceDto priceDto : exportList) {
            LinkedHashMap<String, String> data = new LinkedHashMap<>();
            for (String column : columns) {
                String value = "";
                if (column.equals("deliveryOrgId")) {
                    //收货机构
                    if (priceDto.getDeliveryOrgId() != null) {
                        for (Organization organ : organizationList) {
                            if (organ.getId().equals(priceDto.getDeliveryOrgId())) {
                                value = organ.getName();
                            }
                        }
                    }
                } else if (column.equals("receiveOrgId")) {
                    //收货机构
                    if (priceDto.getReceiveOrgId() != null) {
                        for (Organization organ : organizationList) {
                            if (organ.getId().equals(priceDto.getReceiveOrgId())) {
                                value = organ.getName();
                            }
                        }
                    }
                } else if (column.equals("unitVolumePrice")) {
                    //标准体积参考价
                    value = String.valueOf(priceDto.getUnitVolumePrice());
                } else if (column.equals("unitWeightPrice")) {
                    //标准重量参考价
                    value = String.valueOf(priceDto.getUnitWeightPrice());
                } else if (column.equals("thresholdVolume")) {
                    //体积阈值
                    value = String.valueOf(priceDto.getThresholdVolume());
                } else if (column.equals("thresholdVolumePrice")) {
                    //超体积阈值价格
                    value = String.valueOf(priceDto.getThresholdVolumePrice());
                } else if (column.equals("thresholdWeight")) {
                    //重量阈值
                    value = String.valueOf(priceDto.getThresholdWeight());
                } else if (column.equals("thresholdWeightPrice")) {
                    //超重量阈值价格
                    value = String.valueOf(priceDto.getThresholdWeightPrice());
                } else if (column.equals("singlePiecePrice")) {
                    //单价参考价
                    value = String.valueOf(priceDto.getSinglePiecePrice());
                } else if (column.equals("abnormityCoefficient")) {
                    //异形件系数
                    value = String.valueOf(priceDto.getAbnormityCoefficient());
                } else if (column.equals("equipmentCoefficient")) {
                    //设备系数
                    value = String.valueOf(priceDto.getEquipmentCoefficient());
                } else if (column.equals("status")) {
                    switch (priceDto.getStatus()) {
                        case 1:
                            value = "有效";
                            break;
                        case 2:
                            value = "无效";
                            break;
                        default:
                            value = "";
                    }

                } else if (column.equals("updateTime")) {
                    value = DateUtils.getStrDate(priceDto.getUpdateTime(), "yyyy-MM-dd HH:mm:ss");
                }
                data.put(column, value);
            }
            result.add(data);
        }

        exporterFactory.process(response, result, new ExporterHead("参考价设置"), ReferencePriceExporterTemplate.class, columns);

    }

ExporterConfig类

   exporterTemplate.put(ReferencePriceExporterTemplate.class, getReferencePriceExporterTemplate());
       @Bean
    public ReferencePriceExporterTemplate getReferencePriceExporterTemplate() {
        ReferencePriceExporterTemplate referencePriceExporterTemplate = new ReferencePriceExporterTemplate();
        referencePriceExporterTemplate.setDefaultFileName("参考价设置");
        referencePriceExporterTemplate.setStartRowNumber(3);
        return referencePriceExporterTemplate;
    }

ReferencePriceExporterTemplate类

package com.opensesame.platform.web.exporter.template;

import com.opensesame.core.lang.Tuple;
import com.opensesame.core.util.DateUtils;
import com.opensesame.platform.web.exporter.head.ExporterHead;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.RegionUtil;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SuppressWarnings("unchecked")
public class ReferencePriceExporterTemplate extends AbstractExporterTemplate {

    private static final Map<String, Tuple<String, Integer>> METADATA = new HashMap<String, Tuple<String, Integer>>();

    static {
        METADATA.put("deliveryOrgId", new Tuple<String, Integer>("收货机构", 20 * 256));
        METADATA.put("receiveOrgId", new Tuple<String, Integer>("到货机构", 20 * 256));
        METADATA.put("unitVolumePrice", new Tuple<String, Integer>("标准体积参考价(元 /m3)", 25 * 256));
        METADATA.put("unitWeightPrice", new Tuple<String, Integer>("标准重量参考价(元 /kg)", 25 * 256));
        METADATA.put("thresholdVolume", new Tuple<String, Integer>("体积阈值(m3)", 20 * 256));
        METADATA.put("thresholdVolumePrice", new Tuple<String, Integer>("超体积阈值价格(元/m3)", 25 * 256));
        METADATA.put("thresholdWeight", new Tuple<String, Integer>("重量阈值(kg)", 20 * 256));
        METADATA.put("thresholdWeightPrice", new Tuple<String, Integer>("超重量阈值价格(元/kg)", 25 * 256));
        METADATA.put("singlePiecePrice", new Tuple<String, Integer>("单件参考价", 15 * 256));
        METADATA.put("abnormityCoefficient", new Tuple<String, Integer>("异形件系数", 15 * 256));
        METADATA.put("equipmentCoefficient", new Tuple<String, Integer>("设备系数", 15 * 256));
        METADATA.put("status", new Tuple<String, Integer>("状态", 15 * 256));
        METADATA.put("updateTime", new Tuple<String, Integer>("时间", 25 * 256));
    }

    @Override
    public void drawHead(Workbook workBook, Sheet sheet, ExporterHead exporterHead, CellStyle cellStyle, Object... args) {
        List<String> columns = (List<String>) args[0];
        // 设置标题
        CellRangeAddress head = new CellRangeAddress(0, 0, 0, columns.size());
        sheet.addMergedRegion(head);
        Cell headCell = sheet.createRow(0).createCell(0);
        headCell.setCellValue(exporterHead.getTitle());
        headCell.setCellStyle(getHeadCellStyle(workBook));
        RegionUtil.setBorderBottom(XSSFCellStyle.BORDER_THIN, head, sheet, workBook);
        RegionUtil.setBorderLeft(XSSFCellStyle.BORDER_THIN, head, sheet, workBook);
        RegionUtil.setBorderRight(XSSFCellStyle.BORDER_THIN, head, sheet, workBook);
        RegionUtil.setBorderTop(XSSFCellStyle.BORDER_THIN, head, sheet, workBook);
        // 设置时间
        CellRangeAddress date = new CellRangeAddress(1, 1, 0, columns.size());
        sheet.addMergedRegion(date);
        Cell dateCell = sheet.createRow(1).createCell(0);
        dateCell.setCellValue("导出时间:" + DateFormatUtils.format(new Date(), DateUtils.DATE_TIME_FORMAT));
        dateCell.setCellStyle(getDateCellStyle(workBook));
        RegionUtil.setBorderBottom(XSSFCellStyle.BORDER_THIN, date, sheet, workBook);
        RegionUtil.setBorderLeft(XSSFCellStyle.BORDER_THIN, date, sheet, workBook);
        RegionUtil.setBorderRight(XSSFCellStyle.BORDER_THIN, date, sheet, workBook);
        RegionUtil.setBorderTop(XSSFCellStyle.BORDER_THIN, date, sheet, workBook);

        Row row = sheet.createRow(2);

        int columnNum = 0;

        CellStyle titleCellStyle = getTitleCellStyle(workBook);
        for (String column : columns) {
            Cell cell = row.createCell(columnNum++);
            cell.setCellStyle(titleCellStyle);
            cell.setCellValue(METADATA.get(column).getA());
        }
                //将字段改为数字格式
        List<LinkedHashMap> data = (List<LinkedHashMap>) args[1];

        int startRow = 3;
        for (LinkedHashMap<String, Object> temp : data) {
            Row dataRow = sheet.createRow(startRow++);
            int rowNum = 0;
            for (Map.Entry<String, Object> value : temp.entrySet()) {
                Cell cell = dataRow.createCell(rowNum++);
                if (value.getKey().equals("capacity") || value.getKey().equals("netWeight")) {
                    CellStyle cellStyleNumber = getCellStyle(workBook);
                    cell.setCellStyle(cellStyleNumber);
                    cell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
                    cell.setCellValue(Double.parseDouble(value.getValue().toString()));
                } else {
                    cell.setCellStyle(cellStyle);
                    cell.setCellValue(value.getValue().toString());
                }
            }
        }
    }

    @Override
    public void windup(Workbook workBook, Sheet sheet, ExporterHead exporterHead, CellStyle cellStyle, Object... args) {
        List<String> columns = (List<String>) args[0];
        int columnNum = 0;
        //去掉列自适应宽度
//        sheet.autoSizeColumn(columnNum++, true);
        for (String column : columns) {
            sheet.setColumnWidth(columnNum++, METADATA.get(column).getB());
        }
    }

    /**
     * 获取单元格样式
     *
     * @param workBook
     * @return
     */
    public static CellStyle getHeadCellStyle(Workbook workBook) {
        CellStyle style = workBook.createCellStyle();
        style.setAlignment(CellStyle.ALIGN_CENTER);
        Font font = workBook.createFont();
        font.setFontName("Calibri");
        font.setBoldweight(Font.BOLDWEIGHT_BOLD);
        font.setFontHeightInPoints((short) 20);
        style.setFont(font);
        return style;
    }

    /**
     * 获取单元格样式
     *
     * @param workBook
     * @return
     */
    public static CellStyle getDateCellStyle(Workbook workBook) {
        CellStyle style = workBook.createCellStyle();
        style.setAlignment(CellStyle.ALIGN_CENTER);
        Font font = workBook.createFont();
        font.setFontName("Calibri");
        font.setFontHeightInPoints((short) 12);
        style.setFont(font);
        return style;
    }

    /**
     * 获取单元格样式
     *
     * @param workBook
     * @return
     */
    public static CellStyle getTitleCellStyle(Workbook workBook) {
        CellStyle style = workBook.createCellStyle();
        style.setAlignment(CellStyle.ALIGN_CENTER);
        style.setBorderBottom(XSSFCellStyle.BORDER_THIN);
        style.setBorderTop(XSSFCellStyle.BORDER_THIN);
        style.setBorderRight(XSSFCellStyle.BORDER_THIN);
        style.setBorderLeft(XSSFCellStyle.BORDER_THIN);
        Font font = workBook.createFont();
        font.setFontName("Calibri");
        font.setFontHeightInPoints((short) 12);
        style.setFont(font);
        return style;
    }

}
java小童鞋
关注
【SpringBoot】37、SpringBoot整合EasyPoi自定义字典导出Excel
Asurplus
11-06 22万+
前面我们介绍了 SpringBoot 中使用 JeecgBoot 的 Autopoi 导出 Excel，其实 Autopoi 的底层也是 EasyPoi，对于 Excel 的导入/导出也是非常方便的。那 EasyPoi 也是基于 POI 的，如果对这方面想要深究的，可以先看看原生 POI 的导入/导出方式，你会回来选择 EasyPoi 的 一、简介 EasyPoi 功能如同名字 easy，主打的功能就是容易，让一个没见接触过poi的人员就可以方便的写出 Excel 导出，Excel 模板导出，Excel 导
【SpringBoot】28、SpringBoot中使用JeecgBoot的Autopoi导出Excel
热门推荐
Asurplus
08-05 22万+
说到导出 Excel，我们首先会想到 poi、jsxl 等，使用这些工具会显得笨重，学习难度大。今天学习使用 JeecgBoot 中的 Autopoi 导出 Excel，底层基于 easypoi，使用简单，还支持数据字典方式 一、开发前戏 1、引入 maven 依赖 <!-- AutoPoi Excel工具类--> <dependency> <groupId>org.jeecgframework</groupId> <artifactId
java导出excel的两种方式
jiankang66的博客
04-05 20万+
一、在后台实现，利用java的poi 1、导入jar包，需要导入lib文件夹下如下包： poi-3.11-20141221.jar poi-ooxml.jar poi-ooxml-schemas.jar 2、在util下写一个公共类，该类主要利用Jakarta POI HSSF API组件（用于操作Excel的组件），主要部分包括Excel对象，样式和格式，还有辅助操作。 常用组件： ...............
FreeMarker导出Excel
weixin_45001953的博客
06-26 5448
FreeMarker导出Excel 导出Excel的方式有许多，例如，使用POI自定义单元格，EasyPOI封装的各种导出等等。但是对应一些复杂的Excel，使用FreeMarker模板引擎导出Excel可能更为方便。废话不多说了，上源码： 1，设计模板 将需要替换的数据，如果是单个属性值，使用${属性值},如果是集合list,使用￥{list.属性值}，如下图： 2，转为XML 填好之后另存为 XML电子表格，如下图： 3，修改模板 将模板放到项目下或者固定路径下，这个根据项目的要求，如果需要对立面的
Vue3 导出excel
A12536365214的博客
07-27 3607
xlsx。
poi导出excel
mettle_heng的博客
02-22 9046
JavaPOI导出Excel有三种形式，他们分别是 1.HSSFWorkbook 2.XSSFWorkbook 3.SXSSFWorkbook。 HSSFWorkbook:是操作Excel2003以前（包括2003）的版本，扩展名是.xls； XSSFWorkbook:是操作Excel2007后的版本，扩展名是.xlsx； SXSSFWorkbook:是操作Excel2007后的版本，扩展名是.xlsx； 第一种：HSSFWorkbook poi导出excel最常用的方式；但是此种方式的局限
Navicat导出excel表
li90901的博客
11-27 1712
注意：没有选择要导出的项目就会报这个错，Please select the export object(s).请选择要导出的项目，在源表中选择要导出的表就好了，点击左边的方框，选中就是有打勾的状态，然后再点击下一步，一般导出一直默认点击下一步，最后点个开始和关闭。如果想只要某几列，就把全部字段前面打勾取消，再看可用字段，选择想要的就好了）2、选择你需要的格式，excel有两种格式，都可以选，看你喜欢，然后点击下一步，1、选中一个表---右键---导出向导。3、选中需要导出的表格，然后点击下一步。
Java根据excel模版导出Excel（easyexcel、poi）——含项目测试例子拿来即用
@素素~的博客
02-26 5733
Java根据excel模版导出Excel（easyexcel、poi）——含项目测试例子拿来即用
前端实现导出excel
sinat_22065775的博客
12-19 2265
Excel导出
android 导出Excel列表
Master-D的博客
09-09 2700
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、android导出Excel使用什么库 二、使用步骤 1.封装一个Utils 2.使用方法 总结 前言 本文主要是针对列表数据导出excel模板代码 提示：以下是本篇文章正文内容，下面案例可供参考 一、android导出Excel使用什么库 implementation 'net.sourceforge.jexcelapi:jxl:2.6.12' 二、使用步骤 1.封装一个U
基于SpringBoot和POI实现单线程和多线程导出Excel.zip
12-17
基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip...
Unity导出Excel
04-20
本文将深入探讨如何在Unity中导出Excel，并介绍相关知识点。 首先，Unity导出Excel的关键在于找到合适的插件或库。常见的有ExcelExport、NatCruise等，这些插件能够帮助开发者在Unity中创建和写入Excel文件。例如，...
easyPoi模板导出Excel报表(xls 和xlsx 都支持)
02-07
《使用EasyPoi模板导出Excel报表：xls与xlsx格式全面解析》 在现代企业管理和数据分析中，Excel报表起着至关重要的作用。它不仅能够直观地展示数据，还能进行复杂的数据处理和分析。然而，手动创建和维护大量报表是...
易语言高级表格快速导出EXCEL.7z
05-16
《易语言高级表格快速导出EXCEL》是一个关于如何在易语言编程环境中高效地将数据导出为Excel格式的教程。易语言是中国本土开发的一种面向对象的、易学易用的编程语言，它旨在降低编程的难度，让更多人能够参与到程序...
易语言高级表格导出EXCEL
04-21
在"易语言高级表格导出EXCEL"这个主题中，我们主要关注的是如何使用易语言来操作表格数据，并将这些数据高效地导出到Microsoft Excel格式。易语言提供了丰富的库函数和组件，使得开发者可以方便地实现对表格数据的...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 94
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 547
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 220
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 426
Android的系统结构的设计混合了分层设计和分块设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值