Java读取Excel内容，最后获得一个list对象

news2024/11/19 1:33:20

代码层

public R importPackage(MultipartFile multipartFile) {
        try {
            log.info("multipartFile = " + multipartFile);
            log.info("ContentType = " + multipartFile.getContentType());
            log.info("OriginalFilename = " + multipartFile.getOriginalFilename());
            log.info("Name = " + multipartFile.getName());
            log.info("Size = " + multipartFile.getSize());
            //这里就是读取Excel中的数据
            List<PackageExcel> mlist = ExcelImportUtil.readExcel(PackageExcel.class, multipartFile);
            //这里就是根据文件名读取sheet页的名称，拿到我们想要的sheet页的数据
            String fileName = multipartFile.getOriginalFilename();
             InputStream is = multipartFile.getInputStream();
            Workbook workbook = null;
            if (fileName.endsWith("xlsx")) {
                workbook = new XSSFWorkbook(is);
            }
            if (fileName.endsWith("xls")) {
                workbook = new HSSFWorkbook(is);
            }
            //获取sheet页的名称
            String name = workbook.getSheetName(0);
            List<PackageExcel> mlists = mlist.stream().map(f -> f.setUnitName(name)).collect(Collectors.toList());
           
        } catch (Exception e) {
            log.error("导入包模版失败！", e);
            throw new RuntimeException(e.getMessage());
        }
    }

ExcelImportUtil工具类

package com.cloud.disinfectsupply.util;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.ft.disinfectsupply.excel.ExcelColumn;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.CharUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.http.MediaType;
import org.springframework.util.Assert;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Slf4j
public class ExcelImportUtil {

    private final static String EXCEL2003 = "xls";
    private final static String EXCEL2007 = "xlsx";

    public static <T> List<T> readExcel(Class<T> cls, MultipartFile file){

        String fileName = file.getOriginalFilename();
        if (!fileName.matches("^.+\\.(?i)(xls)$") && !fileName.matches("^.+\\.(?i)(xlsx)$")) {
            log.error("上传文件格式不正确");
            Assert.isTrue(false, "上传文件格式不正确");
        }
        List<T> dataList = new ArrayList<>();
        Workbook workbook = null;
        try {
            InputStream is = file.getInputStream();
            if (fileName.endsWith(EXCEL2007)) {
//                FileInputStream is = new FileInputStream(new File(path));
                workbook = new XSSFWorkbook(is);
            }
            if (fileName.endsWith(EXCEL2003)) {
//                FileInputStream is = new FileInputStream(new File(path));
                workbook = new HSSFWorkbook(is);
            }
            if (workbook != null) {
                //类映射  注解 value-->bean columns
                Map<String, List<Field>> classMap = new HashMap<>();
                List<Field> fields = Stream.of(cls.getDeclaredFields()).collect(Collectors.toList());
                fields.forEach(
                        field -> {
                            ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
                            if (annotation != null) {
                                String value = annotation.value().trim();
                                if (StringUtils.isBlank(value)) {
                                    return;//return起到的作用和continue是相同的 语法
                                }
                                if (!classMap.containsKey(value)) {
                                    classMap.put(value, new ArrayList<>());
                                }
                                field.setAccessible(true);
                                classMap.get(value).add(field);
                            }
                        }
                );
                //索引-->columns
                Map<Integer, List<Field>> reflectionMap = new HashMap<>(16);
                //默认读取第一个sheet
                Sheet sheet = workbook.getSheetAt(0);
                Row _firstRow = null;
                boolean firstRow = true;
                for (int i = sheet.getFirstRowNum(); i <= sheet.getLastRowNum(); i++) {
                    Row row = sheet.getRow(i);
                    //首行  提取注解
                    if (firstRow) {
                        _firstRow = row;
                        for (int j = row.getFirstCellNum(); j <= row.getLastCellNum(); j++) {
                            Cell cell = row.getCell(j);
                            String cellValue = getCellValue(cell);
                            if (classMap.containsKey(cellValue)) {
                                reflectionMap.put(j, classMap.get(cellValue));
                            }
                        }
                        firstRow = false;
                    } else {
                        //忽略空白行
                        if (row == null) {
                            continue;
                        }
                        try {
                            T t = cls.newInstance();
                            //判断是否为空白行
                            boolean allBlank = true;
                            for (int j = row.getFirstCellNum(); j <= row.getLastCellNum(); j++) {
                                Cell cell = row.getCell(j);
                                String cellValue = getCellValue(cell);
                                if (reflectionMap.containsKey(j)) {

                                    if (StringUtils.isNotBlank(cellValue)) {
                                        allBlank = false;
                                    }
                                    List<Field> fieldList = reflectionMap.get(j);
                                    fieldList.forEach(
                                            x -> {
                                                try {
                                                    handleField(t, cellValue, x);
                                                } catch (Exception e) {
                                                    log.error(String.format("reflect field:%s value:%s exception!", x.getName(), cellValue), e);
                                                }
                                            }
                                    );
                                } else {
                                    /*if(t instanceof ImportMonResVo) {
                                        String title = getCellValue( _firstRow.getCell(j));
                                        if(!StringHelper.isEmpty(title)) {
                                            MonTypeDefAttr monTypeDefAttr = new MonTypeDefAttr();
                                            monTypeDefAttr.setCnName(title);
                                            monTypeDefAttr.setValue(cellValue);
                                            ((ImportMonResVo)t).getExAttrs().add(monTypeDefAttr);
                                        }
                                    }*/
                                }
                            }
                            if (!allBlank) {
                                dataList.add(t);
                            } else {
                                log.warn(String.format("row:%s is blank ignore!", i));
                            }
                        } catch (Exception e) {
                            log.error(String.format("parse row:%s exception!", i), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error(String.format("parse excel exception!"), e);
        } finally {
            if (workbook != null) {
                try {
                    workbook.close();
                } catch (Exception e) {
                    log.error(String.format("parse excel exception!"), e);
                }
            }
        }
        return dataList;
    }

    private static <T> void handleField(T t, String value, Field field) throws Exception {
        Class<?> type = field.getType();
        if (type == null || type == void.class || StringUtils.isBlank(value)) {
            return;
        }
        if (type == Object.class) {
            field.set(t, value);
            //数字类型
        } else if (type.getSuperclass() == null || type.getSuperclass() == Number.class) {
            if (type == int.class || type == Integer.class) {
                field.set(t, NumberUtils.toInt(value));
            } else if (type == long.class || type == Long.class) {
                field.set(t, NumberUtils.toLong(value));
            } else if (type == byte.class || type == Byte.class) {
                field.set(t, NumberUtils.toByte(value));
            } else if (type == short.class || type == Short.class) {
                field.set(t, NumberUtils.toShort(value));
            } else if (type == double.class || type == Double.class) {
                field.set(t, NumberUtils.toDouble(value));
            } else if (type == float.class || type == Float.class) {
                field.set(t, NumberUtils.toFloat(value));
            } else if (type == char.class || type == Character.class) {
                field.set(t, CharUtils.toChar(value));
            } else if (type == boolean.class) {
                field.set(t, BooleanUtils.toBoolean(value));
            } else if (type == BigDecimal.class) {
                field.set(t, new BigDecimal(value));
            }
        } else if (type == Boolean.class) {
            field.set(t, BooleanUtils.toBoolean(value));
        } else if (type == Date.class) {
            //
            field.set(t, value);
        } else if (type == String.class) {
            field.set(t, value);
        } else {
            Constructor<?> constructor = type.getConstructor(String.class);
            field.set(t, constructor.newInstance(value));
        }
    }

    private static String getCellValue(Cell cell) {
        if (cell == null) {
            return "";
        }

        if (cell.getCellType() == CellType.NUMERIC) {
            if (HSSFDateUtil.isCellDateFormatted(cell)) {
                return HSSFDateUtil.getJavaDate(cell.getNumericCellValue()).toString();
            } else {
                return new BigDecimal(cell.getNumericCellValue()).toString();
            }
        } else if (cell.getCellType() == CellType.STRING) {
            return StringUtils.trimToEmpty(cell.getStringCellValue());
        } else if (cell.getCellType() == CellType.FORMULA) {
            return StringUtils.trimToEmpty(cell.getCellFormula());
        } else if (cell.getCellType() == CellType.BLANK) {
            return "";
        } else if (cell.getCellType() == CellType.BOOLEAN) {
            return String.valueOf(cell.getBooleanCellValue());
        } else if (cell.getCellType() == CellType.ERROR) {
            return "ERROR";
        } else {
            return cell.toString().trim();
        }

    }

    public static <T> void writeExcel(HttpServletResponse response, List<T> dataList, Class<T> cls,String filePath){
        Field[] fields = cls.getDeclaredFields();
        List<Field> fieldList = Arrays.stream(fields)
                .filter(field -> {
                    ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
                    if (annotation != null) {
                        field.setAccessible(true);
                        return true;
                    }
                    return false;
                }).collect(Collectors.toList());

        Workbook wb = new XSSFWorkbook();
        Sheet sheet = wb.createSheet("Sheet1");
        AtomicInteger ai = new AtomicInteger();
        {
            Row row = sheet.createRow(ai.getAndIncrement());
            AtomicInteger aj = new AtomicInteger();
            //写入头部
            fieldList.forEach(field -> {
                ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
                String columnName = "";
                if (annotation != null) {
                    columnName = annotation.value();
                }
                Cell cell = row.createCell(aj.getAndIncrement());

                CellStyle cellStyle = wb.createCellStyle();
                cellStyle.setFillForegroundColor(IndexedColors.WHITE.getIndex());
                cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
                cellStyle.setAlignment(HorizontalAlignment.CENTER);

                Font font = wb.createFont();
                font.setFontHeightInPoints((short)14);
                cellStyle.setFont(font);
                cell.setCellStyle(cellStyle);
                cell.setCellValue(columnName);
            });
        }
        if (CollectionUtils.isNotEmpty(dataList)) {
            dataList.forEach(t -> {
                Row row1 = sheet.createRow(ai.getAndIncrement());
                AtomicInteger aj = new AtomicInteger();
                fieldList.forEach(field -> {
                    Class<?> type = field.getType();
                    Object value = "";
                    try {
                        value = field.get(t);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    Cell cell = row1.createCell(aj.getAndIncrement());
                    if (value != null) {
                        if (type == Date.class) {
                            cell.setCellValue(value.toString());
                        } else {
                            cell.setCellValue(value.toString());
                        }
                        cell.setCellValue(value.toString());
                    }
                });
            });
        }
        //冻结窗格
        wb.getSheet("Sheet1").createFreezePane(0, 1, 0, 1);
        //浏览器下载excel
        //buildExcelDocument("abbot.xlsx",wb,response);
        //生成excel文件
        //buildExcelFile("d:/default.xlsx",wb);

        buildExcelFile(safeToString(filePath,"d:/default.xlsx"),wb);
    }

    public static <T> void writeExcel(HttpServletResponse response, List<T> dataList, Class<T> cls){
        writeExcel(response,  dataList, cls,"");
    }

    public static <T> void writeExcelByPage(HttpServletResponse response, List<T> dataList, Class<T> cls, Workbook wb, String sheetName){
        Field[] fields = cls.getDeclaredFields();
        List<Field> fieldList = Arrays.stream(fields)
                .filter(field -> {
                    ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
                    if (annotation != null) {
                        field.setAccessible(true);
                        return true;
                    }
                    return false;
                }).collect(Collectors.toList());
        Sheet sheet = wb.createSheet(sheetName);
        AtomicInteger ai = new AtomicInteger();
        {
            Row row = sheet.createRow(ai.getAndIncrement());
            AtomicInteger aj = new AtomicInteger();
            //写入头部
            fieldList.forEach(field -> {
                ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
                String columnName = "";
                if (annotation != null) {
                    columnName = annotation.value();
                }
                Cell cell = row.createCell(aj.getAndIncrement());

                CellStyle cellStyle = wb.createCellStyle();
                cellStyle.setFillForegroundColor(IndexedColors.WHITE.getIndex());
                cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
                cellStyle.setAlignment(HorizontalAlignment.CENTER);

                Font font = wb.createFont();
//                font.setBoldweight(Font.BOLDWEIGHT_NORMAL);
                font.setFontHeightInPoints((short)14);
                cellStyle.setFont(font);
                cell.setCellStyle(cellStyle);
                cell.setCellValue(columnName);
            });
        }
        if (CollectionUtils.isNotEmpty(dataList)) {
            dataList.forEach(t -> {
                Row row1 = sheet.createRow(ai.getAndIncrement());
                AtomicInteger aj = new AtomicInteger();
                fieldList.forEach(field -> {
                    Class<?> type = field.getType();
                    Object value = "";
                    try {
                        value = field.get(t);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    Cell cell = row1.createCell(aj.getAndIncrement());
                    if (value != null) {
                        if (type == Date.class) {
                            cell.setCellValue(value.toString());
                        } else {
                            cell.setCellValue(value.toString());
                        }
                        cell.setCellValue(value.toString());
                    }
                });
            });
        }
        //冻结窗格
        wb.getSheet(sheetName).createFreezePane(0, 1, 0, 1);
        //浏览器下载excel
        //buildExcelDocument("abbot.xlsx",wb,response);
        //生成excel文件
    }

    /**
     * 浏览器下载excel
     * @param fileName
     * @param wb
     * @param response
     */

    public static  void  buildExcelDocument(String fileName, Workbook wb, HttpServletResponse response){
        try {
            response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
            response.setHeader("Content-Disposition", "attachment;filename="+ URLEncoder.encode(fileName, "utf-8"));
            response.setHeader("FileNames", UUID.randomUUID().toString() +".xls");
            response.setHeader("Access-Control-Expose-Headers", "FileNames");
            response.flushBuffer();
            wb.write(response.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成excel文件
     * @param path 生成excel路径
     * @param wb
     */
    public static  void  buildExcelFile(String path, Workbook wb)  {

        File file = new File(path);
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        if (file.exists()) {
            file.delete();
        }
        FileOutputStream fileOutputStream=null;
        try {
            fileOutputStream=new FileOutputStream(file);
            wb.write(fileOutputStream);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public static String safeToString(Object obj, String def) {
        if (null != obj && !"".equals(obj.toString()) && !"null".equals(obj.toString())) {
            def = obj.toString();
        }
        return def;
    }

}

PackageExcel实体类

package com.ft.disinfectsupply.excel;

import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ColumnWidth;
import com.alibaba.excel.annotation.write.style.ContentStyle;
import com.alibaba.excel.annotation.write.style.HeadRowHeight;
import com.alibaba.excel.annotation.write.style.HeadStyle;
import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.List;

/**
 * @Author caozhenbang
 * @Date: 2023-07-12
 * @Description
 */
@Data
@Accessors(chain = true)
@ApiModel(value = "包模板", description = "包模板")
public class PackageExcel implements Serializable {

    @ApiModelProperty("科室名称" )
    @ExcelColumn("科室")//这个就是Excel里面的表头的名字
    private String deptName;

    @ApiModelProperty("包名称" )
    @ExcelColumn("包名称")
    private String packageName;

    @ApiModelProperty("包总数" )
    @ExcelColumn("包总数")
    private int packageCount;

    @ApiModelProperty("包装材料" )
    @ExcelColumn("包装材料(棉布，纸朔等等)")
    private String packageMaterial;


    @ApiModelProperty("器械" )
    @ExcelColumn("单个包的器械名称")
    private String instrument;


    @ApiModelProperty("器械数量" )
    @ExcelColumn("器械数量")
    private int instrumentCount;

    @ApiModelProperty("器械规格" )
    @ExcelColumn("器械规格(选填)")
    private String instrumentSpecification;


}

Excel样式

Excel样式

Excel表头的字要和实体类中@ExcelColumn对应上，这样才会读取

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1066206.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于 FPGA 的机器博弈五子棋游戏

基于 FPGA 的机器博弈五子棋游戏

基于 FPGA 的机器博弈五子棋游戏 一，设计目的 五子棋是一种深受大众喜爱的游戏，其规则简单,变化多端,非常富有趣味性 和消遣性。棋类游戏在具备娱乐性、益智性的同时也因为其载体大多是手机， 电脑等移动互联网设备导致现代社会低头族等现象更加严重，危害青少年的身 体健康…
阅读更多...
VR全景展示带来旅游新体验，助力旅游业发展！

VR全景展示带来旅游新体验，助力旅游业发展！

引言&#xff1a; VR&#xff08;虚拟现实&#xff09;技术正以惊人的速度改变着各行各业&#xff0c;在旅游业中&#xff0c;VR全景展示也展现了其惊人的影响力&#xff0c;为景区带来了全新的宣传机会和游客体验。 一&#xff0e;什么是VR全景展示&#xff1f; VR全景展示是…
阅读更多...
科创人·TATA木门CIO乐勇斌：数字化变革大坎儿在组织变革，天再冷也要拥抱智能

科创人·TATA木门CIO乐勇斌：数字化变革大坎儿在组织变革，天再冷也要拥抱智能

乐勇斌 TATA木门信息中心总监 10年信息化领域管理咨询经验&#xff0c;熟悉零售、电商、汽车、医药、制造、机械加工、家居制造等行业信息化规划、解决方案、建设和流程落地&#xff1b;具备跨区域、项目集和项目组合管控能力&#xff0c;擅于集团化产供销一体化规划&#xff…
阅读更多...
【Vue基础-数字大屏】自定义主题

【Vue基础-数字大屏】自定义主题

一、apache主题模板 链接https://echarts.apache.org/zh/download-theme.html 二、操作步骤 1、在apache主题模板中定制所需要的主题&#xff0c;如下图点击下载&#xff0c;复制其json 2、回到项目代码&#xff0c;在assets目录下新建index.js文件&#xff0c;新建变量&…
阅读更多...
（三）行为模式：8、状态模式（State Pattern）（C++示例）

（三）行为模式：8、状态模式（State Pattern）（C++示例）

目录 1、状态模式&#xff08;State Pattern&#xff09;含义 2、状态模式的UML图学习 3、状态模式的应用场景 4、状态模式的优缺点 &#xff08;1&#xff09;优点 &#xff08;2&#xff09;缺点 5、C实现状态模式的实例 1、状态模式&#xff08;State Pattern&#x…
阅读更多...
【STM32单片机】俄罗斯方块游戏设计

【STM32单片机】俄罗斯方块游戏设计

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用STM32F103C8T6单片机控制器&#xff0c;使用按键、IIC OLED模块等。 主要功能&#xff1a; 系统运行后&#xff0c;OLED显示俄罗斯方块游戏界面并开始游戏&#xff0c;KEY1键用于方块方向旋转&…
阅读更多...
【交互式阈值二进制图像】采用彩色或单色图像通过交互/手动方式阈值单色图像或彩色图像的单个色带研究（Matlab代码实现）

【交互式阈值二进制图像】采用彩色或单色图像通过交互/手动方式阈值单色图像或彩色图像的单个色带研究（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
MFC ExtTextOut函数学习

MFC ExtTextOut函数学习

ExtTextOut - 扩展的文本输出&#xff1b; win32 api的声明如下&#xff1b; ExtTextOut( DC: HDC; {设备环境句柄} X, Y: Integer; {起点坐标} Options: Longint; {选项} Rect: PRect; {指定显示范围; 0 表示限制范围} Str: PChar; {字符串…
阅读更多...
论文分享 | 利用单模态自监督学习实现多模态AVSR

论文分享 | 利用单模态自监督学习实现多模态AVSR

本次分享上海交通大学发表在 ACL 2022 会议 的论文《Leveraging Unimodal Self-Supervised Learning for Multimodal AVSR》。该论文利用大规模单模态自监督学习构建多模态语音识别模型。 论文地址&#xff1a; https://aclanthology.org/2022.acl-long.308.pdf 代码仓库&am…
阅读更多...
ACM模板修改

ACM模板修改

修改为匿名版本 将 \documentclass[sigconf,authordraft]{acmart} 改为 \documentclass[sigconf,review,anonymous]{acmart} 去掉模板中的无用段落 添加如下语句删除上述段落 \renewcommand\footnotetextcopyrightpermission[1]{} 添加如下语句删除上述段落 \settopmatter…
阅读更多...
2019款保时捷卡宴车发动机故障灯异常点亮

2019款保时捷卡宴车发动机故障灯异常点亮

故障现象 一辆2019款保时捷卡宴车&#xff0c;搭载DCB发动机&#xff0c;累计行驶里程约为9万km。车主反映&#xff0c;该车行驶中发动机故障灯偶尔异常点亮&#xff08;图1&#xff09;&#xff0c;其他无异常&#xff0c;为此在其他维修厂更换过燃油箱通风电磁阀、活性炭罐及…
阅读更多...
品牌举办活动如何提高知名度？媒介盒子告诉你

品牌举办活动如何提高知名度？媒介盒子告诉你

2023年&#xff0c;线下消费端口迎来了迅猛爆发&#xff0c;多数行业进入“复苏反攻”状态之中&#xff0c;但在生活节奏加快&#xff0c;信息碎片化趋势之下&#xff0c;大众的注意力成为稀缺资源&#xff0c;逐渐趋同的套路式营销很难打动人心&#xff0c;对于品牌来说&#…
阅读更多...
python3多线程处理文件

python3多线程处理文件

问题 现在需要对某个文本中的每一条进行处理&#xff0c;例如&#xff1a;对每一行进行同样的操作&#xff0c;现在采用多线程进行&#xff0c;而不是一条一条读取、执行 解决 #! /usr/bin/env python # encoding:utf-8 # Software:PyCharm # Time:2023/10/07 14:30 # Auth…
阅读更多...
k8s 集群安装(vagrant + virtualbox + CentOS8)

k8s 集群安装(vagrant + virtualbox + CentOS8)

主机环境&#xff1a;windows 11 k8s版本&#xff1a;v1.25 dashboard版本&#xff1a;v2.7.0 calico版本&#xff1a; v3.26.1 CentOS8版本&#xff1a;4.18.0-348.7.1.el8_5.x86_64 用到的脚本&#xff1a; https://gitcode.net/sundongsdu/k8s_cluster 1. Vagrant创建…
阅读更多...
乌班图22.04 kubeadm简单搭建k8s集群

乌班图22.04 kubeadm简单搭建k8s集群

1. 我遇到的问题 任何部署类问题实际上对于萌新来说都不算简单&#xff0c;因为没有经验&#xff0c;这里我简单将部署的步骤和想法给大家讲述一下 2. 简单安装步骤 准备 3台标准安装的乌班图server22.04&#xff08;采用vm虚拟机安装&#xff0c;ip为192.168.50.3&#xff0…
阅读更多...
DP1363F与CLRC663的兼容性对比区别

DP1363F与CLRC663的兼容性对比区别

DP1363F收发器DP1363F支持下列操作模式 • 替代兼容CLRC663/RC663 • 读写模式支持 ISO/IEC 14443A/MIFARE • 读写模式支持 SO/IEC 14443IB • JIS X 6319-4 读写模式支持&#xff08;等效于FeliCa1方案&#xff09; • 相应于 ISO/IEC 18092 的被动发起方模式 • 读写模式支持…
阅读更多...
告别繁琐，轻松管理SQLite数据库！极简SQLite数据库管理器上线了

告别繁琐，轻松管理SQLite数据库！极简SQLite数据库管理器上线了

如果你是一名Mac用户&#xff0c;并且经常处理SQLite数据库&#xff0c;那么你一定会遇到繁琐的数据库操作&#xff0c;比如安装各种复杂的软件、编写复杂的SQL语句等等。这些操作不仅费时费力&#xff0c;而且还容易出错。那么是否有一种轻松快捷的方法可以管理SQLite数据库呢…
阅读更多...
Springboot 音乐网站管理系统idea开发mysql数据库web结构java编程计算机网页源码maven项目

Springboot 音乐网站管理系统idea开发mysql数据库web结构java编程计算机网页源码maven项目

一、源码特点 springboot 音乐网站管理系统是一套完善的信息系统&#xff0c;结合springboot框架和bootstrap完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用springboot框架&#xff08;MVC模式开发&#xff09;&#xff0c;系统 具有完整的源代码和数据库&…
阅读更多...
口袋参谋：如何提升宝贝流量？这三种方法超实用！

口袋参谋：如何提升宝贝流量？这三种方法超实用！

​你的店铺能不能出爆款&#xff1f;提升单品流量是关键。 对于新手卖家来说&#xff0c;是缺乏运营技巧和运营经验的&#xff0c;运营技巧主要体现在标题写作、各种图片和视频制作等。 由于新手买家没有经验&#xff0c;习惯于直接使用数据包上传&#xff0c;导致宝贝没有展…
阅读更多...
使用scipy库将离散点连续化

使用scipy库将离散点连续化

离散点连续化用于求满足所有离散点的对应法则F(x)且非离散集合中的值。 如有x[0,1,2,3], y[1,3,2,1],求当x1.5时对应的y是多少&#xff1f; 拟合 可以直接求出对应的函数式&#xff0c;但要求知晓经验函数 from numpy import * from scipy.signal import *# 如线性拟合经验函…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023