基于easyexcel抽取成的公共导出接口

已于 2024-02-21 11:41:05 修改
阅读量111 收藏
点赞数
文章标签： java
于 2023-08-11 10:42:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianqi11/article/details/132225767
版权

controller

package com.zhqc.cloud.wms.common.export.controller;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.zhqc.cloud.common.enums.IOWTBResponseEnum;
import com.zhqc.cloud.common.utils.ConvertUtil;
import com.zhqc.cloud.common.utils.ExceptionUtils;
import com.zhqc.cloud.wms.common.export.factory.ExportServiceFactory;
import com.zhqc.cloud.wms.common.export.handler.CustomerRowWriteHandler;
import com.zhqc.cloud.wms.common.export.model.ExportQuery;
import com.zhqc.cloud.wms.util.ExcelPOJOConvertUtil;
import com.zhqc.framerwork.common.exception.ZhqcValidateException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;

/**
 * @author zdd
 */
@RestController
@Slf4j
@RequestMapping("/export/commonExport")
public class CommonExportController {

    @Resource
    @Lazy
    private ExportServiceFactory exportServiceFactory;

    /**
     * 导出
     */
    @PostMapping("/export")
    public void export(@RequestBody @Validated ExportQuery commonExportQuery) {
        replaceId2Name(commonExportQuery);
        long start = System.currentTimeMillis();
        log.info("开始导出，时间：{}", DateUtil.now());
        long l = System.currentTimeMillis();
        validParam(commonExportQuery);
        ExportServiceFactory.UploadServiceEntry serviceEntry = exportServiceFactory.getService(commonExportQuery.getModuleName());
        //执行方法
        Object result = invokeMethod(serviceEntry, commonExportQuery);
        log.info("查询数据耗时：{}ms", System.currentTimeMillis() - l);
        l = System.currentTimeMillis();
        Object resultObj = ReflectUtil.getFieldValue(result, "list");

        List<?> objects = ExcelPOJOConvertUtil.castList((List<?>) resultObj, serviceEntry.getReturnType());

        log.info("转换时间：{}ms", System.currentTimeMillis() - l);
        l = System.currentTimeMillis();

        log.info("查询需要导出的数据条数：{}", objects.size());

        ExceptionUtils.isNotEmpty(objects, "导出数据为空");

        String resultStr = JSONObject.toJSONString(objects);

        List<Map<String, Object>> resultMap = JSONObject.parseObject(resultStr, new TypeReference<List<Map<String, Object>>>() {
        });

        filterUnwantedFields(resultMap, commonExportQuery);
        log.info("处理时间：{}ms", System.currentTimeMillis() - l);
        l = System.currentTimeMillis();
        generateExcel(resultMap, commonExportQuery);
        log.info("导出时间：{}ms", System.currentTimeMillis() - l);
        log.info("结束导出，时间：{},耗时{}", DateUtil.now(), System.currentTimeMillis() - start);
    }

    private void replaceId2Name(ExportQuery commonExportQuery) {
        List<String> fieldList = commonExportQuery.getFieldList();
        List<String> newFieldList = new ArrayList<>(fieldList.size());
        for (String oldField : fieldList) {
            if (oldField.endsWith("Id")) {
                String newField = oldField.replace("Id", "Name");
                newFieldList.add(newField);
            } else {
                newFieldList.add(oldField);
            }
        }
        commonExportQuery.setFieldList(newFieldList);
    }


    private void generateExcel(List<Map<String, Object>> resultMap, ExportQuery commonExportQuery) {
        long l = System.currentTimeMillis();
        List<List<String>> resultData = transToExportData(resultMap, commonExportQuery);
        List<String> titles = commonExportQuery.getTitles();
        List<List<String>> titleList = transToHead(titles);
        log.info("转换数据耗时：{}ms", System.currentTimeMillis() - l);
        l = System.currentTimeMillis();

        HttpServletResponse response;
        try {
            response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        } catch (Exception e) {
            throw new ZhqcValidateException(IOWTBResponseEnum.CUSTOMIZE_MSG, "获取response失败");
        }

        try {
            assert response != null;
            response.setContentType("application/vnd.ms-excel;charset=utf-8");
            response.setHeader("Content-disposition", "attachment; filename=export.xlsx");
            EasyExcel
                    .write(response.getOutputStream())
                    .registerWriteHandler(new CustomerRowWriteHandler())
                    .head(titleList)
                    .sheet("sheet1")
                    .doWrite(resultData);
        } catch (IOException e) {
            throw new ZhqcValidateException(IOWTBResponseEnum.CUSTOMIZE_MSG, "数据导出失败");
        }
        log.info("写入数据耗时：{}ms", System.currentTimeMillis() - l);

    }

    private List<List<String>> transToHead(List<String> titles) {
        List<List<String>> head = new ArrayList<>();
        for (String title : titles) {
            List<String> headColumn = new ArrayList<>();
            headColumn.add(title);
            head.add(headColumn);
        }
        return head;
    }

    private List<List<String>> transToExportData(List<Map<String, Object>> resultMap, ExportQuery commonExportQuery) {
        List<String> fieldList = commonExportQuery.getFieldList();
        List<List<String>> resultData = new ArrayList<>();
        for (Map<String, Object> map : resultMap) {
            List<String> rowData = new ArrayList<>();
            for (String field : fieldList) {
                Object value = map.get(field);
                if (value instanceof Long){
                    value = DateUtil.format(new Date((Long) value), "yyyy-MM-dd HH:mm:ss");
                }
                rowData.add(StrUtil.isBlankIfStr(value) ? "" : value.toString());
            }
            resultData.add(rowData);
        }
        return resultData;
    }

    private void filterUnwantedFields(List<Map<String, Object>> resultMap, ExportQuery commonExportQuery) {
        List<String> fieldList = commonExportQuery.getFieldList();
        Map<String, List<String>> complexFieldMap = new HashMap<>();
        for (String field : fieldList) {
            if (field.contains(".")) {
                String[] split = field.split("\\.");
                if (split.length > 1) {
                    String complexField = split[0];
                    String complexFieldChild = split[1];
                    if (complexFieldMap.containsKey(complexField)) {
                        complexFieldMap.get(complexField).add(complexFieldChild);
                    } else {
                        List<String> childList = new ArrayList<>();
                        childList.add(complexFieldChild);
                        complexFieldMap.put(complexField, childList);
                    }
                }
            }
        }


        for (Map<String, Object> stringObjectMap : resultMap) {
            Map<String, Object> tempMap = new HashMap<>();
            for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                if (stringObjectEntry.getValue() instanceof JSONObject && complexFieldMap.containsKey(stringObjectEntry.getKey())) {
                    JSONObject jsonObject = (JSONObject) stringObjectEntry.getValue();
                    for (String childField : complexFieldMap.get(stringObjectEntry.getKey())) {
                        tempMap.put(childField, jsonObject.get(childField));
                    }
                }
            }
            stringObjectMap.putAll(tempMap);
        }
        List<String> tempFieldList = new ArrayList<>();
        for (String originalString : fieldList) {
            int lastDotIndex = originalString.lastIndexOf('.');
            String processedString = (lastDotIndex >= 0) ? originalString.substring(lastDotIndex + 1) : originalString;
            tempFieldList.add(processedString);
        }
        fieldList = tempFieldList;
        for (Map<String, Object> map : resultMap) {
            List<String> finalFieldList = fieldList;
            map.entrySet().removeIf(entry -> !finalFieldList.contains(entry.getKey()));
        }
        commonExportQuery.setFieldList(fieldList);
    }

    private void validParam(ExportQuery commonExportQuery) {
        ExceptionUtils.isTrue(commonExportQuery.getFieldList().size() == commonExportQuery.getTitles().size(), "标题和字段数量不一致");

    }

    /**
     * 数据查询
     *
     * @param serviceEntry      服务
     * @param commonExportQuery 查询参数
     * @return 查询结果
     */
    private Object invokeMethod(ExportServiceFactory.UploadServiceEntry serviceEntry, ExportQuery commonExportQuery) {
        try {
            Object paramMap = commonExportQuery.getParamMap();
            Object paramObj = JSONObject.parseObject(JSONObject.toJSONString(paramMap), serviceEntry.getQueryType());

            Object service = serviceEntry.getUploadService();
            return service.getClass().getMethod(serviceEntry.getMethodName(), serviceEntry.getParamType()).invoke(service, paramObj);


        } catch (Exception e) {
            throw new ZhqcValidateException(IOWTBResponseEnum.CUSTOMIZE_MSG, StrUtil.format("下载失败：{}", e.getMessage()));
        }

    }
}

工厂类：

package com.zhqc.cloud.wms.export.factory;

import com.zhqc.cloud.common.utils.ExceptionUtils;
import com.zhqc.cloud.wms.gsp.model.query.DestroyInfoQueryExt;
import com.zhqc.cloud.wms.gsp.model.query.NcrQuery;
import com.zhqc.cloud.wms.gsp.model.query.RecheckQuery;
import com.zhqc.cloud.wms.gsp.model.query.UnsalableForewarnQuery;
import com.zhqc.cloud.wms.gsp.model.vo.NcrVOExt;
import com.zhqc.cloud.wms.gsp.model.vo.RecheckVOExt;
import com.zhqc.cloud.wms.gsp.model.vo.UnsalableForewarnVO;
import com.zhqc.cloud.wms.gsp.service.NcrService;
import com.zhqc.cloud.wms.gsp.service.RecheckService;
import com.zhqc.cloud.wms.gsp.service.UnsalableForewarnService;
import com.zhqc.cloud.wms.gspRecord.model.query.*;
import com.zhqc.cloud.wms.gspRecord.model.vo.*;
import com.zhqc.cloud.wms.gspRecord.service.*;
import com.zhqc.framerwork.common.model.query.BaseQuery;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

/**
 * @author zdd
 */
@Component
@DependsOn
public class ExportServiceFactory {

    @Resource
    @Lazy
    private GspRecInfoService gspRecInfoService;

    @Resource
    @Lazy
    private GspProductQcRecordService gspProductQcRecordService;


    @Resource
    @Lazy
    private GspPaRecordService gspPaRecordService;

    @Resource
    @Lazy
    private GspReviewRecordService gspReviewRecordService;


    @Resource
    @Lazy
    private GspDrpRecordService gspDrpRecordService;

    @Resource
    @Lazy
    private GspTransportTrackRecordService gspTransportTrackRecordService;


    @Resource
    @Lazy
    private GspTransportEntrustedRecordService gspTransportEntrustedRecordService;


    @Resource
    @Lazy
    private GspMaintainConfirmRecordService gspMaintainConfirmRecordService;

    @Resource
    @Lazy
    private GspProMaintainRecordService gspProMaintainRecordService;

    @Resource
    @Lazy
    private GspProRecheckRecordService gspProRecheckRecordService;

    @Resource
    @Lazy
    private GspNgProDestroyRecordService gspNgProDestroyRecordService;

    @Resource
    @Lazy
    private GspProRejectRecordService gspProRejectRecordService;

    @Resource
    @Lazy
    private GspNearTermUrgeSalesRecordService gspNearTermUrgeSalesRecordService;

    @Resource
    @Lazy
    private GspUnsalableUrgeSalesRecordService gspUnsalableUrgeSalesRecordService;

    @Resource
    @Lazy
    private NcrService ncrService;

    @Resource
    @Lazy
    private RecheckService recheckService;
    @Resource
    private GspUnqualifiedRecordService gspUnqualifiedRecordService;
    @Resource
    private GspNgProLossReportRecordService gspNgProLossReportRecordService;

    private Map<String, UploadServiceEntry> serviceMap;

    @Resource
    @Lazy
    private UnsalableForewarnService unsalableForewarnService;


    public UploadServiceEntry getService(String serviceType) {
        ExceptionUtils.isTrue(serviceMap.containsKey(serviceType), "服务类型错误");
        return serviceMap.get(serviceType);
    }

    @PostConstruct
    private void init() {
        serviceMap = new HashMap<>();
        //产品收货记录
        serviceMap.put("gspRecInfo", new UploadServiceEntry(gspRecInfoService, "pageInfo", BaseQuery.class, GspRecInfoQuery.class, GspRecInfoVO.class));
        //产品验收记录
        serviceMap.put("gspProductQcRecord", new UploadServiceEntry(gspProductQcRecordService, "pageInfo", BaseQuery.class, GspProductQcRecordQuery.class, GspProductQcRecordVO.class));
        //产品入库记录
        serviceMap.put("gspPaRecord", new UploadServiceEntry(gspPaRecordService, "pageInfo", BaseQuery.class, GspPaRecordQuery.class, GspPaRecordVO.class));
        //产品出库复核记录
        serviceMap.put("gspReviewRecord", new UploadServiceEntry(gspReviewRecordService, "pageInfo", BaseQuery.class, GspReviewRecordQuery.class, GspReviewRecordVO.class));
        //产品进销存记录
        serviceMap.put("gspDrpRecord", new UploadServiceEntry(gspDrpRecordService, "pageInfo", BaseQuery.class, GspDrpRecordQuery.class, GspDrpRecordVO.class));
        //产品运输追踪记录
        serviceMap.put("gspTransportTrackRecord", new UploadServiceEntry(gspTransportTrackRecordService, "pageInfo", BaseQuery.class, GspTransportTrackRecordQuery.class, GspTransportTrackRecordVO.class));
        //产品委托运输记录
        serviceMap.put("gspTransportEntrustedRecord", new UploadServiceEntry(gspTransportEntrustedRecordService, "pageInfo", BaseQuery.class, GspTransportEntrustedRecordQuery.class, GspTransportEntrustedRecordVO.class));
        //不合格产品记录
        serviceMap.put("gspUnqualifiedRecord", new UploadServiceEntry(gspUnqualifiedRecordService, "pageInfo", BaseQuery.class, GspUnqualifiedRecordQuery.class, GspUnqualifiedRecordVO.class));
        //不合格报损记录
        serviceMap.put("gspUnqualifiedReportingLossesRecord", new UploadServiceEntry(gspNgProLossReportRecordService, "pageInfo", BaseQuery.class, GspNgProLossReportRecordQuery.class, GspNgProLossReportRecordVO.class));

        serviceMap.put("gspMaintainConfirmRecord", new UploadServiceEntry(gspMaintainConfirmRecordService, "pageInfo", BaseQuery.class, GspMaintainConfirmRecordQuery.class, GspMaintainConfirmRecordVO.class));
        serviceMap.put("gspProMaintainRecord", new UploadServiceEntry(gspProMaintainRecordService, "pageInfo", BaseQuery.class, GspProMaintainRecordQuery.class, GspProMaintainRecordVO.class));
        serviceMap.put("gspProRecheckRecord", new UploadServiceEntry(gspProRecheckRecordService, "pageInfo", BaseQuery.class, GspProRecheckRecordQuery.class, GspProRecheckRecordVO.class));
        serviceMap.put("gspNgProDestroyRecord", new UploadServiceEntry(gspNgProDestroyRecordService, "pageInfo", BaseQuery.class, DestroyInfoQueryExt.class, GspNgProDestroyRecordVO.class));
        serviceMap.put("gspProRejectRecord", new UploadServiceEntry(gspProRejectRecordService, "pageInfo", BaseQuery.class, GspProRejectRecordQuery.class, GspProRejectRecordVO.class));
        serviceMap.put("gspNearTermUrgeSalesRecord", new UploadServiceEntry(gspNearTermUrgeSalesRecordService, "pageInfo", BaseQuery.class, GspNearTermUrgeSalesRecordQuery.class, GspNearTermUrgeSalesRecordVO.class));
        serviceMap.put("gspUnsalableUrgeSalesRecord", new UploadServiceEntry(gspUnsalableUrgeSalesRecordService, "pageInfo", BaseQuery.class, GspUnsalableUrgeSalesRecordQuery.class, GspUnsalableUrgeSalesRecordVO.class));

        serviceMap.put("reportPreparation", new UploadServiceEntry(ncrService, "pageInfo", BaseQuery.class, NcrQuery.class, NcrVOExt.class));
        serviceMap.put("qualityReInspectionNotice", new UploadServiceEntry(recheckService, "pageInfo", BaseQuery.class, RecheckQuery.class, RecheckVOExt.class));

        //限销期预警
        serviceMap.put("unsalableForewarn", new UploadServiceEntry(unsalableForewarnService, "pageInfo", BaseQuery.class, UnsalableForewarnQuery.class, UnsalableForewarnVO.class));
    }


    @Data
    @AllArgsConstructor
    public static class UploadServiceEntry {

        /**
         * 服务bean
         */
        private Object uploadService;

        /**
         * 服务方法
         */
        private String methodName;

        /**
         * 方法参数类型（只支持一个）
         */
        private Class<?> paramType;

        /**
         * 真正的查询参数类型
         */
        private Class<?> queryType;

        /**
         * 返回值类型
         */
        private Class<?> returnType;

    }
}

接口查询类：

package com.zhqc.cloud.wms.export.model;

import com.zhqc.framerwork.common.component.excel.vo.ExportRequestVo;
import lombok.Data;

import javax.validation.constraints.NotEmpty;
import java.util.List;
import java.util.Objects;

/**
 * @author zdd
 */
@Data
public class CommonExportQuery extends ExportRequestVo {

    /**
     * 模块名称
     */
    @NotEmpty(message = "模块名称不能为空")
    private String moduleName;

    /**
     * 字段集合
     */
    @NotEmpty(message = "字段集合不能为空")
    private List<String> fieldList;

    /**
     * 字段名集合
     */
    @NotEmpty(message = "字段名集合不能为空")
    private List<String> titles;

    public List<String> getFieldList() {
        fieldList.removeIf(Objects::isNull);
        return fieldList;
    }

    public List<String> getTitles() {
        titles.removeIf(Objects::isNull);
        return titles;
    }
}

自使用列宽工具

package com.zhqc.cloud.wms.util.Excelutils;

import com.alibaba.excel.write.handler.RowWriteHandler;
import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.Row;

/**
 * @author zdd
 */
@Slf4j
public class CustomerRowWriteHandler implements RowWriteHandler {

    @Override
    public void afterRowDispose(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, Row row, Integer relativeRowIndex, Boolean isHead) {
        // 自适应列宽
        int lastColumn = row.getLastCellNum();
        for (int i = 0; i < lastColumn; i++) {
            try {
                String stringCellValue = row.getCell(i).getStringCellValue();
                //获取stringCellValue有多少汉字和多少非汉字
                int count = 0;
                for (int j = 0; j < stringCellValue.length(); j++) {
                    char charAt = stringCellValue.charAt(j);
                    if (charAt >= 0x4E00 && charAt <= 0x9FA5) {
                        count++;
                    }
                }
                //设置列宽
                int columnWidth = row.getSheet().getColumnWidth(i);
                int currentWidth;
                if (count > 0) {
                    currentWidth = isHead ? (count + stringCellValue.length())  << 9 : (count + stringCellValue.length()) << 8;
                } else {
                    currentWidth = isHead ? stringCellValue.length() << 9 : stringCellValue.length() << 8;
                }
                if (columnWidth > currentWidth) {
                    currentWidth = columnWidth;
                }
                row.getSheet().setColumnWidth(i, currentWidth);
            } catch (Exception e) {
                log.info("自适应列宽异常");
            }
        }

        //居中
        CellStyle cellStyle = writeSheetHolder.getSheet().getWorkbook().createCellStyle();
        cellStyle.setAlignment(HorizontalAlignment.CENTER);
        row.setRowStyle(cellStyle);
    }

}
tianqi11
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
EasyExcel 动态表头 导出
11-20
EasyExcel 动态表头 导出 ，非注解，后台导出， 可分页，可限制每页显示行数，依赖 com.alibaba easyexcel
（拿去CV就能用！）EasyExcel读写Excel详细流程（图解+代码）
weixin_73077810的博客
07-18 5730
就看这一个就可以啦！！！EasyExcel读写Excel详细流程（图解+代码）
使用 easyexcel
二营长
04-10 453
使用easyexcel 1. pom引入依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>2.1.6</version> </dependency> 2. Excel
EasyExcel导出excel表公共方法提取工具类
lfylucky的博客
05-15 676
/** * 导出公共方法 * @param maps 导入的数据 * @param pathName 地址+Excel表名 * @param objClass Class对象 */ public void exportExcel(List maps, String pathName, Class<?> objClass){ //指定文件输出位置 OutputStream outputStr.
easyexcel 读取指定行数据_Excel怎么设置只提取指定行中的数据？
weixin_39916758的博客
12-19 2881
Excel怎么设置只提取指定行中的数据？有些时候我们需要从一个excel文件中的数据库中提取指定的行或列中的数据。例如如图示，是国内所有上市公司的行业统计。但是现在我们只需要其中部分上市公司的行业统计，我们怎么办呢，下面分享一个技巧，需要的朋友可以参考下有些时候我们需要从一个excel文件中的数据库中提取指定的行或列中的数据。例如如图示，是国内所有上市公司的行业统计。但是现在我们只需要其中部分上市...
EasyExcel导入excel和导出excel的demo
02-07
springboot集成easyexcel做的导入导出demo，下载即可运行。
EasyExcel导出.txt
11-04
EasyExcel 导出，含动态表头导出
阿里EasyExcel导出案例
01-19
阿里EasyExcel导出案例
easyExcel实现大数据导出
11-13
阿里巴巴easyExcel实现大数据导出！！
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 618
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 697
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 949
GeoServerBasePage 登录
探讨 MyBatis 特殊 SQL 执行技巧与注意事项
良月柒
06-18 606
/MyBatis 作为一个灵活的持久层框架，通过提供丰富的动态 SQL 标签、SQL 片段复用、存储过程调用、复杂结果集处理、分页查询和批量操作等功能，使开发者能够高效地实现各种复杂的 SQL 操作。
SpringCloud Alibaba Sentinel基础入门与安装
小小默：进无止境
06-19 261
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。
Javase.认识异常
最新发布
Joseit的博客
06-21 980
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
Java SE入门及基础（55）& Stream流及常用API
m0_63181360的博客
06-19 481
通过外部迭代，你的应用程序既可以确定要迭代的集合，又可以确定迭代的方式。它可以更轻松地利用并行计算的优势，这涉及将问题分为子问题，同时解决这些问题，然后将解决方案的结果组合到子问题中。）会产生非流结果，例如原始值（如双精度值），集合，或者在forEach的情况下根本没有任何值。它们处理流中的元素：聚合操作从流中而不是直接从集合中处理元素。流将一个基本数据类型的数组转换为包装类型的数组，再将包装类型的数组转换基本数据类型数组。筛选器操作返回一个新流，该流包含与筛选条件（此操作的参数）匹配的元素。
高通Android 12/13 Launcher3修改RecentView与屏幕方向保持一致
qq_15950325的博客
06-18 348
最近同事遇到一个需求说，recentview应用预览与屏幕方向不一致，问题，于是加了一些日志，实现此需求。3、最后展示RecentView与屏幕方向保持一致。2、源码修改diff如下所示。源码修改路径汇总如下。
c# 学习笔记 PropertyChangedEventHandler、 =＞、DependencyObject、DataContext
汤圆
06-19 698
在C#中，和常常与接口一起使用，这是实现数据绑定和通知机制的关键部分，尤其在WPF (Windows Presentation Foundation) 或其他支持数据绑定的UI框架中。
java-System 概述 2
weixin_41247813的博客
06-18 810
模块化和高内聚性是设计优良系统的重要原则。`System`类通过`setSecurityManager`和`getSecurityManager`方法允许设置和获取当前的安全管理器（Security Manager）。`System`类中的许多方法（例如`currentTimeMillis`和`arraycopy`）都是通过类似的机制实现的。- **使用`arraycopy`进行数组拷贝**：与手动循环相比，`System.arraycopy`方法在性能上更优，因为它是本地实现的，直接操作内存。
EasyExcel springboot 公共方法 导出
05-26
以下是一个使用 EasyExcel 导出 Excel 文件的示例代码，该代码可以在 Spring Boot 中作为公共方法使用： ```java import com.alibaba.excel.EasyExcel; import com.alibaba.excel.ExcelWriter; import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值