共赴良策

spring boot项目excel导出功能封装——5.导入带进度以及忽略错误

2025-11-28T01:25:00.000Z

封装的easyexcel，基于注解实现excel的导入导出，以场景来说，就是你有一个现成的分页接口或者一个list接口，只需要添加几个简单的注解，就可以实现excel的导出，也是为了方便有模板生成代码的情况下直接生成导出功能。

这是封装的依赖库源码：https://github.com/chenqi92/allbs-excel

这是这个依赖库的使用示例：https://github.com/chenqi92/allbs-excel-test

依赖库运行后在浏览器中打开：http://localhost:8080/ 即可测试各种示例，参照示例进行使用可以不用看后续的使用说明。

昨晚看到评论，发现确实把这个功能点给漏了。

所以额外加了这一节，用来说明如何使用带进度的导入。

还是需要导入maven最新版本：

<dependency>  
    <groupId>cn.allbsgroupId>  
    <artifactId>allbs-excelartifactId>  
    <version>3.1.0version>  
dependency>

普通带进度的导入

导入的示例代码：
当前示例设置了两种模式，一种是检测到错误不让导入，一种是有错误跳过。通过设置参数skipErrors实现。

@PostMapping("/with-progress")  
@ImportProgress(listener = SseImportProgressListener.class, interval = 100)  
public ResponseEntity importWithProgress(  
        @ImportExcel List users,  
        @RequestAttribute(name = "excelErrors", required = false) List excelErrors,  
        @RequestParam(value = "skipErrors", defaultValue = "false") boolean skipErrors  
) {  
    Map result = new HashMap<>();  
  
    // 计算统计信息  
    int totalRows = users.size() + (excelErrors != null ? excelErrors.size() : 0);  
    int successCount = users.size();  
    int errorCount = excelErrors != null ? excelErrors.size() : 0;  
  
    if (!CollectionUtils.isEmpty(excelErrors)) {  
        if (skipErrors) {  
            // 跳过错误模式：只导入正确的数据  
            result.put("success", true);  
            result.put("message", String.format("导入完成（跳过了 %d 行错误数据）", errorCount));  
            result.put("successCount", successCount);  
            result.put("errorCount", errorCount);  
            result.put("totalRows", totalRows);  
            result.put("skipRate", String.format("%.2f%%", (errorCount * 100.0 / totalRows)));  
  
            // 返回错误摘要  
            List errorSummary = excelErrors.stream()  
                    .limit(10)  // 只返回前10个错误  
                    .flatMap(em -> em.getErrorMessages().stream()  
                            .map(msg -> "行号 " + em.getLineNum() + "：" + msg))  
                    .collect(Collectors.toList());  
            if (errorCount > 10) {  
                errorSummary.add("... 还有 " + (errorCount - 10) + " 行错误数据被跳过");  
            }            result.put("errorSummary", errorSummary);  
        } else {  
            // 严格模式：有错误则拒绝导入  
            List errors = excelErrors.stream()  
                    .limit(20)  // 只返回前20个错误  
                    .flatMap(em -> em.getErrorMessages().stream()  
                            .map(msg -> "行号 " + em.getLineNum() + "：" + msg))  
                    .collect(Collectors.toList());  
            if (errorCount > 20) {  
                errors.add("... 还有 " + (errorCount - 20) + " 行错误");  
            }  
            result.put("success", false);  
            result.put("message", String.format("发现 %d 行数据有错误，请修正后重新导入", errorCount));  
            result.put("errors", errors);  
            result.put("validCount", successCount);  
            result.put("errorCount", errorCount);  
            return ResponseEntity.badRequest().body(result);  
        }    } else {  
        result.put("success", true);  
        result.put("message", "导入成功");  
        result.put("successCount", successCount);  
        result.put("errorCount", 0);  
        result.put("totalRows", totalRows);  
    }  
    // 不返回所有数据，避免响应太大  
    result.put("previewData", users.size() > 10 ? users.subList(0, 10) : users);  
    result.put("hasMore", users.size() > 10);  
  
    return ResponseEntity.ok(result);  
}

我将使用有一行故意不满足校验的模板：

导入后如下：

带进度的如下：

异步导入

可以用几十万条数据进行测试，不然效果不明显。

接口实时返回内容，然后通过另外一个接口获取这个异步任务的动态。代码分为导入和获取状态的接口。异步处理的我就不贴了，可以看示例代码。

/**  
 * 1. 提交异步导入任务  
 */  
@PostMapping("/submit")  
public ResponseEntity submitTask(  
        @RequestParam("file") MultipartFile file,  
        @RequestParam(value = "skipErrors", defaultValue = "false") boolean skipErrors  
) {  
    try {  
        String taskId = asyncImportService.submitTask(file, UserDTO.class, skipErrors);  
  
        Map response = new HashMap<>();  
        response.put("success", true);  
        response.put("taskId", taskId);  
        response.put("message", "任务已提交，请通过taskId查询进度");  
  
        return ResponseEntity.ok(response);  
    } catch (Exception e) {  
        Map response = new HashMap<>();  
        response.put("success", false);  
        response.put("message", "提交任务失败: " + e.getMessage());  
        return ResponseEntity.badRequest().body(response);  
    }}  
  
/**  
 * 2. 获取任务状态  
 */  
@GetMapping("/task/{taskId}")  
public ResponseEntity getTaskStatus(@PathVariable String taskId) {  
    ImportTask task = asyncImportService.getTask(taskId);  
  
    if (task == null) {  
        Map response = new HashMap<>();  
        response.put("success", false);  
        response.put("message", "任务不存在");  
        return ResponseEntity.badRequest().body(response);  
    }  
    Map response = new HashMap<>();  
    response.put("success", true);  
    response.put("taskId", task.getTaskId());  
    response.put("fileName", task.getFileName());  
    response.put("status", task.getStatus().name());  
    response.put("progress", task.getProgress());  
    response.put("totalRows", task.getTotalRows());  
    response.put("processedRows", task.getProcessedRows());  
    response.put("successCount", task.getSuccessCount());  
    response.put("errorCount", task.getErrorCount());  
    response.put("errorMessage", task.getErrorMessage());  
    response.put("createdAt", task.getCreatedAt());  
    response.put("startedAt", task.getStartedAt());  
    response.put("completedAt", task.getCompletedAt());  
  
    // 如果有错误，返回部分错误详情  
    if (task.getErrorList() != null && !task.getErrorList().isEmpty()) {  
        response.put("errors", task.getErrorList().stream()  
                .limit(20)  
                .map(error -> {  
                    Map errorMap = new HashMap<>();  
                    errorMap.put("rowIndex", error.getRowIndex());  
                    errorMap.put("data", error.getData());  
                    errorMap.put("fieldErrors", error.getFieldErrors());  
                    return errorMap;  
                })                .collect(Collectors.toList()));  
        response.put("hasMoreErrors", task.getErrorList().size() > 20);  
    }  
    // 如果完成，返回部分成功数据  
    if (task.getSuccessData() != null && !task.getSuccessData().isEmpty()) {  
        response.put("previewData", task.getSuccessData());  
        response.put("hasMoreData", task.getSuccessCount() > 20);  
    }  
    return ResponseEntity.ok(response);  
}

数据预览和确认导入

类似海康系统里面的那个导入，先将待导入的数据列出来，然后判断是否导入。代码太多了，就不贴了，可以直接看示例。

spring boot项目excel导出功能封装——4.导入

2025-11-27T01:25:00.000Z

说在前面

这是封装的依赖库源码：https://github.com/chenqi92/allbs-excel

这是这个依赖库的使用示例：https://github.com/chenqi92/allbs-excel-test

依赖库运行后在浏览器中打开：http://localhost:8080/ 即可测试各种示例，参照示例进行使用可以不用看后续的使用说明。

使用说明

添加maven依赖

<dependency>  
    <groupId>cn.allbsgroupId>  
    <artifactId>allbs-excelartifactId>  
    <version>3.0.1version>  
dependency>

普通导入

导入首先是需要提供用户一份模板的，用于让用户知道那一列填什么。如下有这么一个模板：

那么导入代码(直接返回展示，实际业务可以进行数据库储存)就是：

@PostMapping("/simple")
public ResponseEntity simpleImport(@ImportExcel List users) {
    Map result = new HashMap<>();
    result.put("success", true);
    result.put("message", "导入成功");
    result.put("count", users.size());
    result.put("data", users);
    return ResponseEntity.ok(result);
}

@Data
public class UserDTO {

    @ExcelProperty(value = "用户ID", index = 0)
    @NotNull(message = "用户ID不能为空")
    private Long id;

    @ExcelProperty(value = "用户名", index = 1)
    @NotBlank(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名长度必须在2-20之间")
    private String username;

    @ExcelProperty(value = "邮箱", index = 2)
    @Email(message = "邮箱格式不正确")
    private String email;

    @ExcelProperty(value = "创建时间", index = 3)
    @DateTimeFormat("yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;

    @ExcelProperty(value = "年龄", index = 4)
    private Integer age;

    @ExcelProperty(value = "状态", index = 5)
    private String status;
}

带验证的导入，让用户和开发知道导入数据的哪一行存在问题

上述代码已经完成了一个导入功能，实际导入过程中难免遇到用户瞎填的情况，那么上面的UserDTO中字段上的校验就可以生效了。比如我不填用户名或者瞎填邮箱。

示例代码：

@PostMapping("/validate")
public ResponseEntity importWithValidation(
        @ImportExcel List users,
        @RequestAttribute(name = "excelErrors", required = false) List excelErrors
) {
    Map result = new HashMap<>();

    if (!CollectionUtils.isEmpty(excelErrors)) {
        // 使用默认格式化的错误消息
        List errors = excelErrors.stream()
                .flatMap(em -> em.getErrorMessages().stream()
                        .map(msg -> "行号 " + em.getLineNum() + "：" + msg))
                .collect(Collectors.toList());

        result.put("success", false);
        result.put("message", "数据验证失败");
        result.put("errors", errors);
        result.put("validCount", users.size());
        result.put("errorCount", excelErrors.size());
        return ResponseEntity.badRequest().body(result);
    }

    result.put("success", true);
    result.put("message", "导入成功");
    result.put("count", users.size());
    result.put("data", users);
    return ResponseEntity.ok(result);
}

实际效果为：

这是额外可以获取到的内容(errors中为简单的提示，fieldErrors内容较全，用于更多不同的业务场景使用)：

图片导入

首先是模板：

图片导入的示例代码(注意ProductImageDTO这个类中的关于图片字段的定义方式)：

@PostMapping("/import")
public ResponseEntity importWithImages(@ImportExcel List products) {

    Map result = new HashMap<>();
    result.put("success", true);
    result.put("message", "导入成功");
    result.put("count", products.size());

    // 处理导入的数据
    List> productInfos = new ArrayList<>();
    for (ProductImageDTO product : products) {
       Map info = new HashMap<>();
       info.put("id", product.getId());
       info.put("name", product.getName());
       info.put("price", product.getPrice());
       info.put("stock", product.getStock());
       info.put("description", product.getDescription());

       // 图片信息
       info.put("hasMainImage", product.getMainImage() != null && !product.getMainImage().isEmpty());
       info.put("hasThumbnail", product.getThumbnail() != null && product.getThumbnail().length > 0);
       info.put("imageListCount",
             product.getImageList() != null ? product.getImageList().size() : 0);

       // 如果需要，可以在这里保存图片到服务器
       // saveImage(product.getMainImage(), "main_" + product.getId());
       // saveImage(product.getThumbnail(), "thumbnail_" + product.getId());

       productInfos.add(info);
    }

    result.put("products", productInfos);

    log.info("Imported {} products with images", products.size());
    return ResponseEntity.ok(result);
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ProductImageDTO {

    @ExcelProperty("商品ID")
    private Long id;

    @ExcelProperty("商品名称")
    private String name;

    @ExcelProperty("商品价格")
    private BigDecimal price;

    /**
     * 商品主图（单张图片）
     * 
     * 导出时：支持 URL、本地路径、Base64
     * 导入时：读取为 Base64 字符串
     * 
     */
    @ExcelProperty("商品主图")
    @ExcelImage(width = 120, height = 120)
    private String mainImage;

    /**
     * 商品缩略图（字节数组）
     * 
     * 导出时：直接使用字节数组
     * 导入时：读取为字节数组
     * 
     */
    @ExcelProperty("商品缩略图")
    @ExcelImage(width = 80, height = 80, type = ExcelImage.ImageType.BYTES)
    private byte[] thumbnail;

    /**
     * 商品图集（多张图片）
     * 
     * 导出时：支持多张图片水平排列
     * 导入时：读取为 Base64 字符串列表
     * 
     */
    @ExcelProperty(value = "商品图集", converter = ImageListConverter.class)
    @ExcelImage(width = 100, height = 100)
    private List imageList;

    @ExcelProperty("库存数量")
    private Integer stock;

    @ExcelProperty("商品描述")
    private String description;

}

实际导入后，debug可以获取到的内容为:

导出时这三列分别为base64的字符串、图片、图片。导入后获取到的内容为base64的字符串、转为二进制的数据、转为base64的图片。后续可以上传至minio等进行处理。

嵌套对象导入

这个是第二篇嵌套对象字段提取部分的数据导入。
对应的视图对象长这样，注意其中的@NestedProperty注解，其中department、department2、department3和department4实际上都只导出了一个字段：

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class NestedPropertyExampleDTO {  
  
    @ExcelProperty("员工ID")  
    private Long id;  
  
    @ExcelProperty("员工姓名")  
    private String name;  
  
    // ==================== 单层嵌套对象 ====================  
    @ExcelProperty(value = "部门名称", converter = NestedObjectConverter.class)  
    @NestedProperty("name")  
    private Department department;  
  
    @ExcelProperty(value = "部门编码", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "code", nullValue = "未分配")  
    private Department department2;  
  
    // ==================== 多层嵌套对象 ====================  
    @ExcelProperty(value = "直属领导", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "leader.name", nullValue = "暂无")  
    private Department department3;  
  
    @ExcelProperty(value = "领导电话", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "leader.phone", nullValue = "-")  
    private Department department4;  
  
    // ==================== 集合类型 ====================  
    // 技能列表（内部字段，不导出）  
    @ExcelIgnore  
    private List skills;  
  
    @ExcelProperty(value = "主要技能", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[0]", nullValue = "无")  
    private List mainSkill;  
  
    @ExcelProperty(value = "所有技能", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[*]", separator = ",", maxJoinSize = 5)  
    private List allSkills;  
  
    // ==================== Map 类型 ====================  
    // 扩展属性（内部字段，不导出）  
    @ExcelIgnore  
    private Map properties;  
  
    @ExcelProperty(value = "工作城市", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[city]", nullValue = "-")  
    private Map city;  
  
    @ExcelProperty(value = "入职年份", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[joinYear]", nullValue = "-")  
    private Map joinYear;  
}

所以使用该视图对象进行导入时，数据也会对应的缺少，如果想完整导入，看后面的示例。
这是导入使用的方法，和前面的实际上一样：

@PostMapping("/nested-property")  
public Map nestedPropertyImport(@ImportExcel List data) {  
    Map result = new HashMap<>();  
    result.put("success", true);  
    result.put("count", data.size());  
    result.put("data", data);  
    result.put("message", "成功导入 " + data.size() + " 条数据");  
  
    log.info("Imported {} records", data.size());  
    return result;  
}

嵌套对象多行聚合导入

使用的是之前明细展开导出功能，大概可以理解为返回的对象list有5条数据，但是每条数据有子对象list，每个里面2条数据，实际上导出就是10条数据。

导出的内容示例为(实际接口返回list有5条数据，但是因为部分数据有子数据会自动撑开)：

那么将这个多行聚合数据导入使用的代码示例为：

@PostMapping("/flatten-list-order")
public Map flattenListOrderImport(@ImportExcel List data) {
    Map response = new HashMap<>();
    response.put("success", true);
    response.put("count", data.size());
    response.put("data", data);
    response.put("message", "成功导入 " + data.size() + " 个订单");

    log.info("Imported {} orders", data.size());
    return response;
}

接收到的数据为：

可以看到实际上也是五条数据，并且嵌套的对象list或者对象也正常将数据加载进去了。

spring boot项目excel导出功能封装——3.图表导出

2025-11-26T01:25:00.000Z

说在前面

这是封装的依赖库源码：https://github.com/chenqi92/allbs-excel

这是这个依赖库的使用示例：https://github.com/chenqi92/allbs-excel-test

依赖库运行后在浏览器中打开：http://localhost:8080/ 即可测试各种示例，参照示例进行使用可以不用看后续的使用说明。

这篇比较无聊，主要是导出数据时添加额外的chart属性自动生成图表。实际上数据导出后手动也可以指定生成图表，还更灵活。

使用说明

添加maven依赖

<dependency>  
    <groupId>cn.allbsgroupId>  
    <artifactId>allbs-excelartifactId>  
    <version>3.0.0version>  
dependency>

折线图

代码示例(视图对象所有都用的同一样，区别只有chat属性设置，所以我后续就不放下面这个ChartDataDTO视图对象了)：

@GetMapping("/line")  
@ExportExcel(  
    name = "折线图-销售趋势",  
    sheets = @Sheet(sheetName = "Sales Data"),  
    chart = @ExcelChart(  
       title = "Monthly Sales Trend",  
       enabled = true,  
       type = ExcelChart.ChartType.LINE,  
       xAxisField = "Month",  
       yAxisFields = {"Sales", "Cost", "Profit"},  
       startRow = 0,  
       startColumn = 8,  
       endRow = 20,  
       endColumn = 18,  
       xAxisTitle = "Month",  
       yAxisTitle = "Amount (USD)",  
       showLegend = true,  
       legendPosition = ExcelChart.LegendPosition.BOTTOM  
    )  
)  
public List exportLineChart(@RequestParam(defaultValue = "12") int months) {  
    log.info("Exporting line chart with {} months of data", months);  
    return testDataService.generateChartData(Math.min(months, 12));  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class ChartDataDTO {  
  
    @ExcelProperty(value = "Month", index = 0)  
    private String month;  
  
    @ExcelProperty(value = "Sales", index = 1)  
    private BigDecimal sales;  
  
    @ExcelProperty(value = "Cost", index = 2)  
    private BigDecimal cost;  
  
    @ExcelProperty(value = "Profit", index = 3)  
    private BigDecimal profit;  
  
    @ExcelProperty(value = "Growth Rate (%)", index = 4)  
    private Double growthRate;  
  
    @ExcelProperty(value = "Units Sold", index = 5)  
    private Integer unitsSold;  
}

生成效果：

柱状图（纵向）

@GetMapping("/column")  
@ExportExcel(  
    name = "柱状图-销售对比",  
    sheets = @Sheet(sheetName = "Sales Comparison"),  
    chart = @ExcelChart(  
       title = "Monthly Sales vs Cost",  
       enabled = true,  
       type = ExcelChart.ChartType.COLUMN,  
       xAxisField = "Month",  
       yAxisFields = {"Sales", "Cost"},  
       startRow = 0,  
       startColumn = 8,  
       endRow = 20,  
       endColumn = 18,  
       xAxisTitle = "Month",  
       yAxisTitle = "Amount (USD)",  
       showLegend = true,  
       legendPosition = ExcelChart.LegendPosition.TOP  
    )  
)  
public List exportColumnChart(@RequestParam(defaultValue = "12") int months) {  
    log.info("Exporting column chart with {} months of data", months);  
    return testDataService.generateChartData(Math.min(months, 12));  
}

实际效果：

条形图（横向）

@GetMapping("/bar")  
@ExportExcel(  
    name = "条形图-月度利润",  
    sheets = @Sheet(sheetName = "Monthly Profit"),  
    chart = @ExcelChart(  
       title = "Monthly Profit Analysis",  
       enabled = true,  
       type = ExcelChart.ChartType.BAR,  
       xAxisField = "Month",  
       yAxisFields = {"Profit"},  
       startRow = 0,  
       startColumn = 8,  
       endRow = 20,  
       endColumn = 18,  
       xAxisTitle = "Month",  
       yAxisTitle = "Profit (USD)",  
       showLegend = true,  
       legendPosition = ExcelChart.LegendPosition.RIGHT  
    )  
)  
public List exportBarChart(@RequestParam(defaultValue = "12") int months) {  
    log.info("Exporting bar chart with {} months of data", months);  
    return testDataService.generateChartData(Math.min(months, 12));  
}

实际效果：

饼图

代码示例：

@GetMapping("/pie")  
@ExportExcel(  
    name = "饼图-销售分布",  
    sheets = @Sheet(sheetName = "Sales Distribution"),  
    chart = @ExcelChart(  
       title = "Sales Distribution by Month",  
       enabled = true,  
       type = ExcelChart.ChartType.PIE,  
       xAxisField = "Month",  
       yAxisFields = {"Sales"},  
       startRow = 0,  
       startColumn = 8,  
       endRow = 20,  
       endColumn = 18,  
       showLegend = true,  
       legendPosition = ExcelChart.LegendPosition.RIGHT  
    )  
)  
public List exportPieChart(@RequestParam(defaultValue = "12") int months) {  
    log.info("Exporting pie chart with {} months of data", months);  
    return testDataService.generateChartData(Math.min(months, 12));  
}

实际效果：

面积图

@GetMapping("/area")  
@ExportExcel(  
    name = "面积图-累计销售",  
    sheets = @Sheet(sheetName = "Cumulative Sales"),  
    chart = @ExcelChart(  
       title = "Cumulative Sales and Cost",  
       enabled = true,  
       type = ExcelChart.ChartType.AREA,  
       xAxisField = "Month",  
       yAxisFields = {"Sales", "Cost"},  
       startRow = 0,  
       startColumn = 8,  
       endRow = 20,  
       endColumn = 18,  
       xAxisTitle = "Month",  
       yAxisTitle = "Amount (USD)",  
       showLegend = true,  
       legendPosition = ExcelChart.LegendPosition.BOTTOM  
    )  
)  
public List exportAreaChart(@RequestParam(defaultValue = "12") int months) {  
    log.info("Exporting area chart with {} months of data", months);  
    return testDataService.generateChartData(Math.min(months, 12));  
}

实际效果：

多个独立图表导出

@GetMapping("/layered-analysis")  
@ExportExcel(  
    name = "分层分析-多图表",  
    sheets = @Sheet(sheetName = "Layered Analysis"),  
    charts = {  
       @ExcelChart(  
          title = "Revenue Analysis",  
          enabled = true,  
          type = ExcelChart.ChartType.LINE,  
          xAxisField = "Month",  
          yAxisFields = {"Sales"},  
          startRow = 0,  
          startColumn = 8,  
          endRow = 15,  
          endColumn = 17,  
          xAxisTitle = "Month",  
          yAxisTitle = "Sales (USD)",  
          showLegend = true,  
          legendPosition = ExcelChart.LegendPosition.BOTTOM  
       ),  
       @ExcelChart(  
          title = "Cost Analysis",  
          enabled = true,  
          type = ExcelChart.ChartType.AREA,  
          xAxisField = "Month",  
          yAxisFields = {"Cost"},  
          startRow = 17,  
          startColumn = 8,  
          endRow = 32,  
          endColumn = 17,  
          xAxisTitle = "Month",  
          yAxisTitle = "Cost (USD)",  
          showLegend = true,  
          legendPosition = ExcelChart.LegendPosition.TOP  
       ),  
       @ExcelChart(  
          title = "Profit Analysis",  
          enabled = true,  
          type = ExcelChart.ChartType.COLUMN,  
          xAxisField = "Month",  
          yAxisFields = {"Profit"},  
          startRow = 0,  
          startColumn = 19,  
          endRow = 15,  
          endColumn = 27,  
          xAxisTitle = "Month",  
          yAxisTitle = "Profit (USD)",  
          showLegend = true,  
          legendPosition = ExcelChart.LegendPosition.RIGHT  
       )  
    })  
public List exportLayeredAnalysis(@RequestParam(defaultValue = "12") int months) {  
    log.info("Exporting layered analysis with {} months of data", months);  
    return testDataService.generateChartData(Math.min(months, 12));  
}

实际效果：

spring boot项目excel导出功能封装——2.高级导出

2025-11-25T01:25:00.000Z

说在前面

封装的easyexcel，基于注解实现excel的导入导出，以场景来说，就是你有一个现成的分页接口或者一个list接口，只需要添加几个简单的注解，就可以实现excel的导出，也是为了方便有模板生成代码的情况下直接生成导出功能。
这是封装的依赖库源码：https://github.com/chenqi92/allbs-excel
这是这个依赖库的使用示例：https://github.com/chenqi92/allbs-excel-test
依赖库运行后在浏览器中打开：http://localhost:8080/ 即可测试各种示例，参照示例进行使用可以不用看后续的使用说明。
这是第二篇了，第一篇可以往前翻翻，后一篇是讲excel中的统计图的，没啥用可以跳过之后看最后一篇导入篇。

使用说明

添加maven依赖

<dependency>  
    <groupId>cn.allbsgroupId>  
    <artifactId>allbs-excelartifactId>  
    <version>3.0.0version>  
dependency>

合并单元格

导出中不可避免遇到的情况，但是需要将需要合并的字段进行排序，以便能够识别并自动合并。
主要通过@ExportExcel的autoMerge = true属性实现，并在对应字段添加注解@ExcelMerge
代码示例：

@GetMapping("/merge")  
@ExportExcel(  
    name = "部门员工列表",  
    sheets = @Sheet(  
        sheetName = "员工信息",  
        autoMerge = true  // 启用自动合并  
    )  
)  
public List mergeExport(@RequestParam(defaultValue = "20") int count) {  
    return testDataService.generateEmployees(count);  
}

@Data  
public class EmployeeDTO {  
  
    @ExcelProperty(value = "部门", index = 0)  
    @ExcelMerge  // 标记需要合并的字段  
    private String department;  
  
    @ExcelProperty(value = "姓名", index = 1)  
    @ExcelMerge(dependOn = "department")  // 依赖部门列  
    private String name;  
  
    @ExcelProperty(value = "职位", index = 2)  
    @ExcelMerge(dependOn = "name")  // 依赖姓名列  
    private String position;  
  
    @ExcelProperty(value = "工资", index = 3)  
    private BigDecimal salary;  
  
    @ExcelProperty(value = "入职日期", index = 4)  
    private String joinDate;  
}

实际效果(数据并不合理，姓名一列专门设置了一样的名字用于测试合并)：

数据脱敏

实际导出过程中肯定无法避免遇到需要数据脱敏的情况，如果是数据库层面脱敏过这边可以忽略，但是如果数据库层面没脱敏但是又需要在最后展示进行脱敏，就是这个功能的实际应用。
主要方式依赖字段注解@Desensitize，内置提供手机号、身份证号、邮箱、银行卡号、姓名、地址、固定电话、车牌号、自定义这些脱敏方式，如果内置的脱敏达不到你的要求，可以进行自定义实现，自定义采取设置前几位和最后几位保留的脱敏方式，除了前后的指定位数，其他内容变更为*。本来还想可以自定义字符填充，想想挺傻的，用默认的*就可以了。
使用示例：

@GetMapping("/desensitize")  
@ExportExcel(  
    name = "敏感信息用户列表",  
    sheets = @Sheet(sheetName = "用户信息")  
)  
public List desensitizeExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateSensitiveUsers(count);  
}

@Data  
public class SensitiveUserDTO {  
  
    @ExcelProperty(value = "用户ID", index = 0)  
    private Long id;  
  
    @ExcelProperty(value = "姓名", index = 1, converter = DesensitizeConverter.class)  
    @Desensitize(type = DesensitizeType.NAME)  
    private String name;  
  
    @ExcelProperty(value = "手机号", index = 2, converter = DesensitizeConverter.class)  
    @Desensitize(type = DesensitizeType.MOBILE_PHONE)  
    private String phone;  
  
    @ExcelProperty(value = "身份证", index = 3, converter = DesensitizeConverter.class)  
    @Desensitize(type = DesensitizeType.ID_CARD)  
    private String idCard;  
  
    @ExcelProperty(value = "邮箱", index = 4, converter = DesensitizeConverter.class)  
    @Desensitize(type = DesensitizeType.EMAIL)  
    private String email;  
  
    @ExcelProperty(value = "银行卡", index = 5, converter = DesensitizeConverter.class)  
    @Desensitize(type = DesensitizeType.BANK_CARD)  
    private String bankCard;  
  
    @ExcelProperty(value = "地址", index = 6, converter = DesensitizeConverter.class)  
    @Desensitize(type = DesensitizeType.ADDRESS)  
    private String address;  
  
    @ExcelProperty(value = "性别", index = 7, converter = DictConverter.class)  
    @ExcelDict(dictType = "sys_user_sex")  
    private String sex;  
  
    @ExcelProperty(value = "状态", index = 8, converter = DictConverter.class)  
    @ExcelDict(dictType = "sys_user_status")  
    private String status;  
}

实现效果：

导出进度

如果数据量较大，提供给前端实时进度，避免用户焦躁。这是实际效果，在allbs-excel-test中有具体的实现了，主要通过接口方法注解@ExportProgress进行实现，源码中定义了一个接口ExportProgressListener,通过实现这个接口可以获取导出过程中的进度，然后通过websocket或者sse主动推送给前端即可。

代码实现，注意下面的ExportProgress：

@GetMapping("/with-progress")  
@ExportExcel(  
    name = "用户列表-带进度",  
    sheets = @Sheet(sheetName = "用户信息")  
)  
@ExportProgress(  
    listener = SseProgressListener.class,  
    interval = 100  // 每 100 行触发一次进度回调  
)  
public List exportWithProgress(@RequestParam(defaultValue = "5000") int count,  
                                                  @RequestParam(required = false) String sessionId) {  
    return testDataService.generateSensitiveUsers(count);  
}

这是进度的实现，实现进度监听然后处理开始、进度更新、结束、错误几个方法即可：

@Component  
public class SseProgressListener implements ExportProgressListener {  
  
    private static final Logger log = LoggerFactory.getLogger(SseProgressListener.class);  
  
    @Autowired  
    private ProgressService progressService;  
  
    @Override  
    public void onStart(int totalRows, String sheetName) {  
        log.info("========== 开始导出 ==========");  
        log.info("Sheet名称: {}", sheetName);  
        log.info("总行数: {}", totalRows);  
  
        String sessionId = getSessionId();  
        if (sessionId != null) {  
            progressService.sendProgress(sessionId,  
                ProgressService.ProgressMessage.start(totalRows, sheetName));  
        }    }  
    @Override  
    public void onProgress(int currentRow, int totalRows, double percentage, String sheetName) {  
        log.info("导出进度: {}/{} ({:.2f}%) - {}",  
            currentRow, totalRows, percentage, sheetName);  
  
        String sessionId = getSessionId();  
        if (sessionId != null) {  
            progressService.sendProgress(sessionId,  
                ProgressService.ProgressMessage.progress(currentRow, totalRows, percentage, sheetName));  
        }    }  
    @Override  
    public void onComplete(int totalRows, String sheetName) {  
        log.info("========== 导出完成 ==========");  
        log.info("Sheet名称: {}", sheetName);  
        log.info("总行数: {}", totalRows);  
  
        String sessionId = getSessionId();  
        if (sessionId != null) {  
            progressService.sendProgress(sessionId,  
                ProgressService.ProgressMessage.complete(totalRows, sheetName));  
            // 延迟关闭连接，给前端足够时间主动关闭（避免触发前端 onerror）  
            new Thread(() -> {  
                try {  
                    Thread.sleep(5000);  // 延长到 5 秒，让前端有足够时间主动关闭  
                    progressService.closeEmitter(sessionId);  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }            }).start();        }    }  
    @Override  
    public void onError(Exception exception, String sheetName) {  
        log.error("========== 导出失败 ==========");  
        log.error("Sheet名称: {}", sheetName);  
        log.error("错误信息: {}", exception.getMessage(), exception);  
  
        String sessionId = getSessionId();  
        if (sessionId != null) {  
            progressService.sendProgress(sessionId,  
                ProgressService.ProgressMessage.error(sheetName, exception.getMessage()));  
            progressService.closeEmitter(sessionId);  
        }    }  
    /**  
     * 从请求参数中获取 sessionId  
     */    private String getSessionId() {  
        try {  
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();  
            if (attributes != null) {  
                return attributes.getRequest().getParameter("sessionId");  
            }        } catch (Exception e) {  
            log.warn("无法获取 sessionId: {}", e.getMessage());  
        }        return null;  
    }}

冻结窗格和筛选

当前示例为将第一行冻结，无论你滚动到哪一行可以保证知道某列是干什么的，同时实现某一列的筛选功能。说实话这玩意完全可以导出后自己设置一下，但是如果你遇到操作excel有很大进步空间的的现场运维，那么这个功能还是有点意义的。看下方示例的ExcelSheetStyle注解。
实现代码：

@GetMapping("/formula")  
@ExportExcel(  
    name = "销售统计数据",  
    sheets = @Sheet(sheetName = "销售统计")  
)  
public List formulaExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateFormulaData(count);  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
@ExcelSheetStyle(  
    freezeRow = 1,  
    autoFilter = true,  
    defaultColumnWidth = 15  
)  
public class FormulaDataDTO {  
  
    @ExcelProperty(value = "Product Name", index = 0)  
    private String productName;  
  
    @ExcelProperty(value = "Unit Price", index = 1)  
    private BigDecimal unitPrice;  
  
    @ExcelProperty(value = "Quantity", index = 2)  
    private Integer quantity;  
  
    @ExcelProperty(value = "Total Price", index = 3)  
    private BigDecimal totalPrice;  
  
    @ExcelProperty(value = "Tax (10%)", index = 4)  
    private BigDecimal taxAmount;  
  
    @ExcelProperty(value = "Final Amount", index = 5)  
    private BigDecimal finalAmount;  
}

实际效果(不是2-10没了，是我往下滚动隐藏了，体现了冻结窗口之功能)：

图标集

该功能是为了让冰冷无趣的文字鲜活一些，说直白一点就是没什么卵用的功能。既然是没啥用的功能，我就不详细说了，贴个代码示例，有兴趣的去看源码好了。
实现效果：

代码示例：

@GetMapping("/conditional-format")  
@ExportExcel(  
    name = "员工绩效-条件格式",  
    sheets = @Sheet(sheetName = "员工绩效"),  
    writeHandler = {ConditionalFormatWriteHandler.class}  
)  
public List conditionalFormatExport(@RequestParam(defaultValue = "15") int count) {  
    return testDataService.generatePerformanceData(count);  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class PerformanceDataDTO {  
  
    @ExcelProperty(value = "Employee", index = 0)  
    private String employeeName;  
  
    @ExcelProperty(value = "Department", index = 1)  
    private String department;  
  
    @ExcelProperty(value = "Score", index = 2)  
    @ConditionalFormat(  
        type = ConditionalFormat.FormatType.ICON_SET,  
        iconSet = ConditionalFormat.IconSetType.THREE_TRAFFIC_LIGHTS_1  
    )  
    private Integer score;  
  
    @ExcelProperty(value = "Sales Amount", index = 3)  
    @ConditionalFormat(  
        type = ConditionalFormat.FormatType.ICON_SET,  
        iconSet = ConditionalFormat.IconSetType.THREE_ARROWS  
    )  
    private BigDecimal sales;  
  
    @ExcelProperty(value = "Completion Rate", index = 4)  
    @ConditionalFormat(  
        type = ConditionalFormat.FormatType.ICON_SET,  
        iconSet = ConditionalFormat.IconSetType.THREE_FLAGS  
    )  
    private Double completionRate;  
}

Excel 加密

包含两种方式，一种简单的设置即可，还有一种是自定义加密算法(这种方法不支持注解形式，但是我会提供示例)
这是简单加密的示例，看到那个password属性没，加个这玩意即可。

GetMapping("/encrypted")  
@ExportExcel(  
    name = "加密文件-密码password123",  
    sheets = @Sheet(sheetName = "敏感数据"),  
    password = "password123"  // ✨ 使用注解方式设置密码  
)  
public List encryptedExport(@RequestParam(defaultValue = "20") int count) {  
    return testDataService.generateSensitiveUsers(count);  
}

这是指定加密算法的方式，非注解，根据传入的密码加密

@GetMapping("/encrypted-advanced")  
public void encryptedAdvancedExport(@RequestParam(defaultValue = "20") int count,  
                                    @RequestParam(defaultValue = "password123") String password,  
                                    HttpServletResponse response) throws IOException {  
    List data = testDataService.generateSensitiveUsers(count);  
  
    // 先导出到临时文件  
    File tempFile = File.createTempFile("excel_", ".xlsx");  
    tempFile.deleteOnExit();  
    EasyExcel.write(tempFile, SensitiveUserDTO.class)  
        .sheet("敏感数据")  
        .doWrite(data);  
    // 使用 AGILE 算法加密文件  
    File encryptedFile = File.createTempFile("encrypted_", ".xlsx");  
    encryptedFile.deleteOnExit();  
    ExcelEncryptionUtil.encryptFile(  
        tempFile,        encryptedFile,        password,        ExcelEncryption.EncryptionAlgorithm.AGILE  
    );  
  
    // 设置响应头  
    response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");  
    response.setCharacterEncoding("utf-8");  
    String fileName = URLEncoder.encode("加密文件-AGILE-密码" + password, "UTF-8").replaceAll("\\+", "%20");  
    response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");  
  
    // 输出加密文件  
    try (FileInputStream fis = new FileInputStream(encryptedFile)) {  
        byte[] buffer = new byte[8192];  
        int bytesRead;  
        while ((bytesRead = fis.read(buffer)) != -1) {  
            response.getOutputStream().write(buffer, 0, bytesRead);  
        }    }  
    // 清理临时文件  
    tempFile.delete();  
    encryptedFile.delete();
}

多 Sheet 关联导出

可能会有人问，前面一篇明明有过多sheet啊，实际上并不是同一种用法。前一篇是通过返回list的list实现，这边是视图对象中有额外的对象list，所以说完全是两种截然不同的实现。看示例代码

示例代码：

@GetMapping("/multi-sheet")  
@ExportExcel(  
    name = "订单及明细-多Sheet",  
    sheets = @Sheet(sheetName = "订单")  
)  
public List multiSheetExport(@RequestParam(defaultValue = "5") int count) {  
    return testDataService.generateMultiSheetOrders(count);  
}

@Data  
@Builder  
@NoArgsConstructor  
@AllArgsConstructor  
public class MultiSheetOrderDTO {  
  
    /**  
     * 订单号  
     */  
    @ExcelProperty(value = "订单号", index = 0)  
    private String orderNo;  
  
    /**  
     * 客户名称  
     */  
    @ExcelProperty(value = "客户名称", index = 1)  
    private String customerName;  
  
    /**  
     * 订单金额  
     */  
    @ExcelProperty(value = "订单金额", index = 2)  
    private BigDecimal totalAmount;  
  
    /**  
     * 订单状态  
     */  
    @ExcelProperty(value = "订单状态", index = 3)  
    private String status;  
  
    /**  
     * 创建时间  
     */  
    @ExcelProperty(value = "创建时间", index = 4)  
    private LocalDateTime createTime;  
  
    /**  
     * 明细数量  
     */  
    @ExcelProperty(value = "明细数量", index = 5)  
    private Integer itemCount;  
  
    /**  
     * 订单明细（导出到关联 Sheet）  
     */  
    @ExcelProperty(value = "操作", index = 6)  
    @RelatedSheet(sheetName = "订单明细", relationKey = "orderNo", dataType = MultiSheetOrderItemDTO.class, createHyperlink = true, hyperlinkText = "查看明细")  
    private List items;  
  
}

嵌套对象

上面是视图对象中有对象的list，那么肯定也会存在对象中有对象的情况，对象的对象中还有对象，那么肯定就会存在某干层级下有所需字段的情况：
以下代码包含了多种不同的情况所以稍微有点复杂，包括了嵌套单个对象，嵌套基本类型的列表，嵌套Map，看代码和结果理解：

@GetMapping("/nested-property")  
@ExportExcel(  
    name = "嵌套对象示例",  
    sheets = @Sheet(sheetName = "员工信息")  
)  
public List nestedPropertyExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateNestedPropertyExamples(count);  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class NestedPropertyExampleDTO {  
  
    @ExcelProperty("员工ID")  
    private Long id;  
  
    @ExcelProperty("员工姓名")  
    private String name;  
  
    // ==================== 单层嵌套对象 ====================  
    @ExcelProperty(value = "部门名称", converter = NestedObjectConverter.class)  
    @NestedProperty("name")  
    private Department department;  
  
    @ExcelProperty(value = "部门编码", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "code", nullValue = "未分配")  
    private Department department2;  
  
    // ==================== 多层嵌套对象 ====================  
    @ExcelProperty(value = "直属领导", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "leader.name", nullValue = "暂无")  
    private Department department3;  
  
    @ExcelProperty(value = "领导电话", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "leader.phone", nullValue = "-")  
    private Department department4;  
  
    // ==================== 集合类型 ====================  
    // 技能列表（内部字段，不导出）  
    @ExcelIgnore  
    private List skills;  
  
    @ExcelProperty(value = "主要技能", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[0]", nullValue = "无")  
    private List mainSkill;  
  
    @ExcelProperty(value = "所有技能", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[*]", separator = ",", maxJoinSize = 5)  
    private List allSkills;  
  
    // ==================== Map 类型 ====================  
    // 扩展属性（内部字段，不导出）  
    @ExcelIgnore  
    private Map properties;  
  
    @ExcelProperty(value = "工作城市", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[city]", nullValue = "-")  
    private Map city;  
  
    @ExcelProperty(value = "入职年份", converter = NestedObjectConverter.class)  
    @NestedProperty(value = "[joinYear]", nullValue = "-")  
    private Map joinYear;  
}

实际导出的excel为（第一个红框是对象的对象中的内容，第二个框为对象的对象的对象中的内容，第三个箭头为list只获取第一个的情况，第四个箭头为获取所有list数据并用逗号分隔的情况，最后俩箭头就是从Map中取数据的情况，不要被最后俩map字段名称搞混，实际上上面的[city]和[joinYear]是map的key）：
![[Pasted image 20251123194422.png]]

嵌套对象自动横展开

上面的一个示例讲的是从对象的对象中获取一个值的方法，这个示例讲的是讲对象中的对象所有值都带上并展示到excel中的方法。
代码示例（注意看department、parentDept、managerDept三个字段）：

@GetMapping("/flatten-property")  
@ExportExcel(  
    name = "对象展开示例",  
    sheets = @Sheet(sheetName = "员工信息")  
)  
public List flattenPropertyExport(@RequestParam(defaultValue = "10") int count) {  
    // FlattenPropertyWriteHandler 会自动检测 @FlattenProperty 注解并处理嵌套对象展开  
    return testDataService.generateFlattenPropertyExamples(count);  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class FlattenPropertyExampleDTO {  
  
    @ExcelProperty("员工ID")  
    private Long id;  
  
    @ExcelProperty("员工姓名")  
    private String name;  
  
    @ExcelProperty("年龄")  
    private Integer age;  
  
    // 自动展开部门的所有 @ExcelProperty 字段  
    @FlattenProperty(prefix = "部门-")  
    @ExcelIgnore  // 必须添加，否则 EasyExcel 会尝试直接导出 Department 对象  
    private Department department;  
  
    // 自动展开上级部门的所有字段，使用不同的前缀避免冲突  
    @FlattenProperty(prefix = "上级部门-")  
    @ExcelIgnore  // 必须添加  
    private Department parentDept;  
  
    // 递归展开（会自动展开 department 内部的 leader 对象）  
    @FlattenProperty(prefix = "主管-", recursive = true, maxDepth = 2)  
    @ExcelIgnore  // 必须添加  
    private Department managerDept;  
}

实际效果：

嵌套对象垂直展开

视图对象中嵌套对象的list，将这个list对象的内容一并输出到excel表格中。
代码示例：

@GetMapping("/flatten-list-student")  
@ExportExcel(  
    name = "学生课程奖项列表",  
    sheets = @Sheet(sheetName = "学生信息")  
)  
public List flattenListStudentExport(@RequestParam(defaultValue = "5") int count) {  
    return testDataService.generateFlattenListStudents(count);  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class FlattenListStudentDTO {  
  
    @ExcelProperty("学生姓名")  
    private String name;  
  
    @ExcelProperty("学号")  
    private String studentNo;  
  
    @ExcelProperty("班级")  
    private String className;  
  
    // 多个 List - 使用 MAX_LENGTH 策略（默认）  
    @FlattenList(prefix = "课程-")  
    private List courses;  
  
    @FlattenList(prefix = "奖项-")  
    private List awards;  
}

实际导出效果：

动态表头

如果视图对象中存在Map，那么会将该Map内容动态生成表头并填充数据，注意下面的@DynamicHeaders注解的使用。

@GetMapping("/dynamic-header")  
@ExportExcel(  
    name = "动态表头示例",  
    sheets = @Sheet(sheetName = "产品列表")  
)  
public List dynamicHeaderExport(@RequestParam(defaultValue = "15") int count) {   
    return testDataService.generateDynamicHeaderData(count);  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class DynamicHeaderDTO {  
  
    @ExcelProperty("产品ID")  
    private Long productId;  
  
    @ExcelProperty("产品名称")  
    private String productName;  
  
    @ExcelProperty("分类")  
    private String category;  
  
    /**  
     * 动态属性（从数据中自动提取表头）  
     *   
     * 不同产品的属性可能不同，表头动态生成  
     * 
  
     */  
    @DynamicHeaders(strategy = DynamicHeaderStrategy.FROM_DATA, headerPrefix = "属性-",  
          order = DynamicHeaders.SortOrder.ASC)  
    private Map properties;  
  
    /**  
     * 扩展字段（使用预定义表头）  
     */  
    @DynamicHeaders(strategy = DynamicHeaderStrategy.FROM_CONFIG, headers = { "备注1", "备注2", "备注3" },  
          headerPrefix = "扩展-")  
    private Map extFields;  
  
}

实际效果：

spring boot项目excel导出功能封装——1.简单导出

2025-11-24T01:25:00.000Z

说在前面

这是封装的依赖库源码：https://github.com/chenqi92/allbs-excel

这是这个依赖库的使用示例：https://github.com/chenqi92/allbs-excel-test

依赖库运行后在浏览器中打开：http://localhost:8080/ 即可测试各种示例，参照示例进行使用可以不用看后续的使用说明。

前面三篇功能点较为分散，没有特意合并测试，想了想，如果真要那么复杂的表格设置，貌似写模板最方便。

使用说明

添加maven依赖

<dependency>  
    <groupId>cn.allbsgroupId>  
    <artifactId>allbs-excelartifactId>  
    <version>3.0.0version>  
dependency>

基本导出

第一个导出我贴比较详细点的代码，后续就直接说需要添加的内容了。
假设你原本有一个这样的接口

@GetMapping("/simple")  
public List simpleExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateUsers(count);  
}

@Data  
public class UserDTO {  
  
    @NotNull(message = "用户ID不能为空")  
    private Long id;  
  
    @NotBlank(message = "用户名不能为空")  
    @Size(min = 2, max = 20, message = "用户名长度必须在2-20之间")  
    private String username;  
  
    @Email(message = "邮箱格式不正确")  
    private String email;  
  
    @DateTimeFormat("yyyy-MM-dd HH:mm:ss")  
    private LocalDateTime createTime;  
  
    private Integer age;  
  
    private String status;  
}

那么将这个接口变成导出接口，可以增加这些注解：
@ExportExcel,@ExcelProperty就可以变成一个导出接口。
上面的代码就变成了：

@GetMapping("/simple") 
// 导出的excel文件名为用户列表，sheet为用户信息 
@ExportExcel(  
    name = "用户列表",  
    sheets = @Sheet(sheetName = "用户信息")  
)  
public List simpleExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateUsers(count);  
}

@Data  
public class UserDTO {  
  
// index 就是列的排序
    @ExcelProperty(value = "用户ID", index = 0)  
    @NotNull(message = "用户ID不能为空")  
    private Long id;  
  
    @ExcelProperty(value = "用户名", index = 1)  
    @NotBlank(message = "用户名不能为空")  
    @Size(min = 2, max = 20, message = "用户名长度必须在2-20之间")  
    private String username;  
  
    @ExcelProperty(value = "邮箱", index = 2)  
    @Email(message = "邮箱格式不正确")  
    private String email;  
  
    @ExcelProperty(value = "创建时间", index = 3)  
    @DateTimeFormat("yyyy-MM-dd HH:mm:ss")  
    private LocalDateTime createTime;  
  
    @ExcelProperty(value = "年龄", index = 4)  
    private Integer age;  
  
    @ExcelProperty(value = "状态", index = 5)  
    private String status;  
}

导出的效果为：

这是一个最简单的用法，基本上实际业务有这样的也就可以了。

空表头导出

如果实际情况中你的返回结果列表中没有数据，上面的代码不足以导出一个文件，需要添加一个属性clazz = UserDTO.class，那么需要修改一下controller注解为

@GetMapping("/empty")  
@ExportExcel(  
    name = "空用户列表",  
    sheets = @Sheet(  
        sheetName = "用户信息", 
        // 指定数据类型用于生成表头   
        clazz = UserDTO.class  
    )  
)  
public List emptyExport() {  
    return Collections.emptyList();  
}

只导出添加了`@ExcelProperty`注解的字段

当前的实现为如果你的返回结果类中字段没有添加@ExcelProperty注解，那么导出到excel中列名实际上是字段名，那么如何让导出时只展示添加了注解的字段呢？那就是添加onlyExcelProperty = true属性，同时这种方式也可以避免添加过多的@ExcelIgnore。

@GetMapping("/only-annotated")  
@ExportExcel(  
    name = "用户列表-仅注解字段",  
    sheets = @Sheet(sheetName = "用户信息"),  
    // 只导出有 @ExcelProperty 注解的字段
    onlyExcelProperty = true    
)  
public List onlyAnnotatedExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateUsers(count);  
}

多 Sheet 导出

上述内容讲的都是单个sheet导出，实际业务过程肯定会有多个sheet的导出，以下为示例：
实际上就是设置了多个sheet的名称，并返回对于数量的列表。

@GetMapping("/multi-sheet")  
@ExportExcel(  
    name = "综合报表",  
    sheets = {  
        @Sheet(sheetName = "用户信息", clazz = UserDTO.class),  
        @Sheet(sheetName = "订单信息", clazz = OrderDTO.class)  
    })  
public List> multiSheetExport(  
    @RequestParam(defaultValue = "10") int userCount,  
    @RequestParam(defaultValue = "20") int orderCount  
) {  
    List users = testDataService.generateUsers(userCount);  
    List orders = testDataService.generateOrders(orderCount);  
    return Arrays.asList(users, orders);  
}

导出效果：

设定表格的列宽和行高

通过注解@ContentRowHeight(25)和@ColumnWidth实现
代码示例：

@Data  
@ContentRowHeight(25)  
public class ProductDTO {  
  
    @ExcelProperty(value = "产品ID", index = 0)  
    @ColumnWidth(10)  
    private Long id;  
  
    @ExcelProperty(value = "产品名称", index = 1)  
    @ColumnWidth(20)  
    private String name;  
  
    @ExcelProperty(value = "产品分类", index = 2)  
    @ColumnWidth(15)  
    private String category;  
  
    @ExcelProperty(value = "价格", index = 3)  
    @ColumnWidth(15)  
    private BigDecimal price;  
  
    @ExcelProperty(value = "库存", index = 4)  
    @ColumnWidth(10)  
    private Integer stock;  
  
    @ExcelProperty(value = "产品描述", index = 5)  
    @ColumnWidth(50)  
    private String description;  
}

实现效果：

自动行号

实际上没啥用的功能，就是多一列序号。
通过添加注解@ExcelLine实现
代码示例：

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class RowNumberDTO {  
  
    /**  
     * Excel行号 (自动填充,从1开始)  
     */    @ExcelLine  
    @ExcelProperty(value = "行号", index = 0)  
    private Long rowNum;  
  
    @ExcelProperty(value = "产品名称", index = 1)  
    private String productName;  
  
    @ExcelProperty(value = "产品代码", index = 2)  
    private String productCode;  
  
    @ExcelProperty(value = "价格", index = 3)  
    private Double price;  
  
    @ExcelProperty(value = "库存", index = 4)  
    private Integer stock;  
  
    @ExcelProperty(value = "分类", index = 5)  
    private String category;  
  
    /**  
     * 构造方法(不包含rowNum,rowNum由@ExcelLine自动填充)  
     */    public RowNumberDTO(String productName, String productCode, Double price, Integer stock, String category) {  
        this.productName = productName;  
        this.productCode = productCode;  
        this.price = price;  
        this.stock = stock;  
        this.category = category;  
    }}

数据验证功能

限制单元格中的内容，作为导入模板还是挺有用的。
代码示例：

@GetMapping("/validation")  
@ExportExcel(  
    name = "员工信息-数据验证",  
    sheets = @Sheet(sheetName = "员工信息"),  
    writeHandler = {ExcelValidationWriteHandler.class}  
)  
public List validationExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateDataValidationData(count);  
}

如果是要设置指定返回行进行验证可以这么写（1~1000行会有验证，其他行不会）：

@GetMapping("/validation-custom")  
@ExportExcel(  
    name = "员工信息-自定义验证",  
    sheets = @Sheet(  
        sheetName = "员工信息",  
        validationStartRow = 1,  
        validationEndRow = 1000  
    )  
)  
public List validationCustomExport(@RequestParam(defaultValue = "10") int count) {  
    return testDataService.generateDataValidationData(count);  
}

@Data  
@Builder  
@NoArgsConstructor  
@AllArgsConstructor  
public class DataValidationDTO {  
  
    /**  
     * 姓名 - 文本长度验证  
     */  
    @ExcelProperty(value = "姓名", index = 0)  
    @ExcelValidation(type = ValidationType.TEXT_LENGTH, minLength = 2, maxLength = 10, errorMessage = "姓名长度必须在2-10个字符之间", promptMessage = "请输入2-10个字符的姓名", showPromptBox = true)  
    private String name;  
  
    /**  
     * 性别 - 下拉列表验证  
     */  
    @ExcelProperty(value = "性别", index = 1)  
    @ExcelValidation(type = ValidationType.LIST, options = { "男", "女" }, errorMessage = "性别只能选择：男、女", promptMessage = "请选择性别", showPromptBox = true)  
    private String gender;  
  
    /**  
     * 年龄 - 整数范围验证  
     */  
    @ExcelProperty(value = "年龄", index = 2)  
    @ExcelValidation(type = ValidationType.INTEGER, min = 18, max = 65, errorMessage = "年龄必须在18-65之间", promptMessage = "请输入18-65之间的整数", showPromptBox = true)  
    private Integer age;  
  
    /**  
     * 工资 - 小数范围验证  
     */  
    @ExcelProperty(value = "工资", index = 3)  
    @ExcelValidation(type = ValidationType.DECIMAL, min = 3000.0, max = 50000.0, errorMessage = "工资必须在3000-50000之间", promptMessage = "请输入3000-50000之间的数值", showPromptBox = true)  
    private Double salary;  
  
    /**  
     * 入职日期 - 日期验证  
     */  
    @ExcelProperty(value = "入职日期", index = 4)  
    @ExcelValidation(type = ValidationType.DATE, dateFormat = "yyyy-MM-dd", errorMessage = "请输入有效的日期格式", promptMessage = "请输入日期，格式：yyyy-MM-dd", showPromptBox = true)  
    private LocalDate hireDate;  
  
    /**  
     * 部门 - 下拉列表验证  
     */  
    @ExcelProperty(value = "部门", index = 5)  
    @ExcelValidation(type = ValidationType.LIST, options = { "技术部", "销售部", "人事部", "财务部", "运营部" }, errorMessage = "请从下拉列表中选择部门", promptMessage = "请选择部门", showPromptBox = true)  
    private String department;  
  
    /**  
     * 职位 - 下拉列表验证  
     */  
    @ExcelProperty(value = "职位", index = 6)  
    @ExcelValidation(type = ValidationType.LIST, options = { "初级工程师", "中级工程师", "高级工程师", "技术经理", "技术总监" }, errorMessage = "请从下拉列表中选择职位", promptMessage = "请选择职位", showPromptBox = true)  
    private String position;  
  
    /**  
     * 工作年限 - 整数验证（最小值）  
     */  
    @ExcelProperty(value = "工作年限", index = 7)  
    @ExcelValidation(type = ValidationType.INTEGER, min = 0, max = 50, errorMessage = "工作年限必须大于等于0", promptMessage = "请输入工作年限（年）", showPromptBox = true)  
    private Integer workYears;  
  
    /**  
     * 绩效评分 - 小数验证  
     */  
    @ExcelProperty(value = "绩效评分", index = 8)  
    @ExcelValidation(type = ValidationType.DECIMAL, min = 0.0, max = 10.0, errorMessage = "绩效评分必须在0-10之间", promptMessage = "请输入0-10之间的评分", showPromptBox = true)  
    private Double performanceScore;  
  
    /**  
     * 邮箱 - 任意值（仅提示）  
     */  
    @ExcelProperty(value = "邮箱", index = 9)  
    @ExcelValidation(type = ValidationType.ANY, promptMessage = "请输入有效的邮箱地址，例如：example@company.com", showPromptBox = true, showErrorBox = false)  
    private String email;  
  
}

实际的效果如图：

条件样式

根据单元格值自动应用不同样式，不同的颜色、不同字体等，比如以学生分数90分以上一个颜色，60-90一个颜色，60以下一个颜色。注意下方的注解ConditionalStyle的用法。
代码示例：

@GetMapping("/conditional-style")  
@ExportExcel(  
        name = "条件样式示例",  
        sheets = @Sheet(sheetName = "条件样式示例"),  
        writeHandler = {ConditionalStyleWriteHandler.class}  
)  
public List conditionalStyleExport(  
        @RequestParam(defaultValue = "20") int count  
) {  
    return testDataService.generateConditionalStyleData(count);  
}

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class ConditionalStyleDTO {  
  
    @ExcelProperty("学生姓名")  
    private String studentName;  
  
    @ExcelProperty("考试分数")  
    @ConditionalStyle(conditions = { @Condition(value = ">=90", style = @CellStyleDef(backgroundColor = "#00FF00", // 绿色  
          bold = true)), @Condition(value = ">=60", style = @CellStyleDef(backgroundColor = "#FFFF00" // 黄色  
    )), @Condition(value = "<60", style = @CellStyleDef(backgroundColor = "#FF0000", // 红色  
          fontColor = "#FFFFFF")) })  
    private Integer score;  
  
    @ExcelProperty("任务状态")  
    @ConditionalStyle(conditions = {  
          @Condition(value = "已完成", style = @CellStyleDef(backgroundColor = "#00FF00", fontColor = "#FFFFFF")),  
          @Condition(value = "进行中", style = @CellStyleDef(backgroundColor = "#FFFF00")),  
          @Condition(value = "已取消", style = @CellStyleDef(backgroundColor = "#808080", fontColor = "#FFFFFF")) })  
    private String status;  
  
    @ExcelProperty("销售额")  
    @ConditionalStyle(conditions = {  
          @Condition(value = ">=10000", style = @CellStyleDef(backgroundColor = "#FFD700", // 金色  
                bold = true)),  
          @Condition(value = ">=5000", style = @CellStyleDef(backgroundColor = "#87CEEB" // 天蓝色  
          )) })  
    private BigDecimal salesAmount;  
  
    @ExcelProperty("等级")  
    @ConditionalStyle(conditions = {  
          @Condition(value = "regex:^A.*", style = @CellStyleDef(backgroundColor = "#00FF00", bold = true)),  
          @Condition(value = "regex:^B.*", style = @CellStyleDef(backgroundColor = "#FFFF00")),  
          @Condition(value = "regex:^C.*", style = @CellStyleDef(backgroundColor = "#FFA500")) // 橙色  
    })  
    private String grade;  
  
}

导出示例：

导出数据字典转换

实际业务开发过程中肯定无法避免字段以tinyint储存或者有枚举的情况，那么如何处理这种情况？
如下是直接塞入sex和status字段为随机数值的情况，其他数据为随机生成数据，代码示例：

@GetMapping("/export")  
@ExportExcel(  
    name = "字典转换示例",  
    sheets = @Sheet(sheetName = "用户信息")  
)  
public List exportDictExample(@RequestParam(defaultValue = "10") int count) {  
    List list = new ArrayList<>();  
    Random random = new Random();  
  
    String[] departments = {"技术部", "市场部", "人事部", "财务部", "运营部"};  
    String[] usernames = {"张三", "李四", "王五", "赵六", "钱七", "孙八", "周九", "吴十"};  
  
    for (int i = 1; i <= count; i++) {  
        DictExampleDTO dto = new DictExampleDTO();  
        dto.setId((long) i);  
        dto.setUsername(usernames[random.nextInt(usernames.length)] + i);  
  
        // 性别: 数据库存储 0/1/2，导出时会转换为 女/男/未知  
        dto.setSex(String.valueOf(random.nextInt(3))); // 0, 1, 2  
  
        // 状态: 数据库存储 0/1/2，导出时会转换为 正常/禁用/锁定  
        dto.setStatus(String.valueOf(random.nextInt(3))); // 0, 1, 2  
  
        dto.setDepartment(departments[random.nextInt(departments.length)]);  
        dto.setCreateTime(LocalDateTime.now().minusDays(random.nextInt(365)));  
        dto.setRemark("这是测试数据 " + i);  
  
        list.add(dto);  
    }  
    return list;  
}

处理方式为在ExcelProperty中添加属性converter = DictConverter.class并额外添加注解@ExcelDict(dictType = "sys_user_sex")标明用的是哪个字典。

@Data  
public class DictExampleDTO {  
  
    @ExcelProperty(value = "用户ID", index = 0)  
    private Long id;  
  
    @ExcelProperty(value = "用户名", index = 1)  
    private String username;  
  
    /**  
     * 性别字典转换示例  
     * 导出时: 0 → 女, 1 → 男, 2 → 未知  
     * 导入时: 女 → 0, 男 → 1, 未知 → 2  
     */    @ExcelProperty(value = "性别", index = 2, converter = DictConverter.class)  
    @ExcelDict(dictType = "sys_user_sex")  
    private String sex;  
  
    /**  
     * 状态字典转换示例  
     * 导出时: 0 → 正常, 1 → 禁用, 2 → 锁定  
     * 导入时: 正常 → 0, 禁用 → 1, 锁定 → 2  
     */    @ExcelProperty(value = "状态", index = 3, converter = DictConverter.class)  
    @ExcelDict(dictType = "sys_user_status")  
    private String status;  
  
    @ExcelProperty(value = "部门", index = 4)  
    private String department;  
  
    @ExcelProperty(value = "创建时间", index = 5)  
    private LocalDateTime createTime;  
  
    @ExcelProperty(value = "备注", index = 6)  
    private String remark;  
}

这个DictConverter为封装的转换器，同时需要有对应的service实现。示例代码：
static中就是你所需实际项目中的字典值，需要将注解的dictType字段和下面key进行对应。

@Service  
public class DictServiceImpl implements DictService {  
  
    // 模拟字典数据  
    private static final Map> DICT_DATA = new HashMap<>();  
  
    static {  
        // 性别字典  
        Map sexDict = new HashMap<>();  
        sexDict.put("0", "女");  
        sexDict.put("1", "男");  
        sexDict.put("2", "未知");  
        DICT_DATA.put("sys_user_sex", sexDict);  
  
        // 状态字典  
        Map statusDict = new HashMap<>();  
        statusDict.put("0", "正常");  
        statusDict.put("1", "禁用");  
        statusDict.put("2", "锁定");  
        DICT_DATA.put("sys_user_status", statusDict);  
    }  
    @Override  
    public String getLabel(String dictType, String dictValue) {  
        Map dict = DICT_DATA.get(dictType);  
        if (dict != null) {  
            return dict.get(dictValue);  
        }        
        return dictValue;  
    }  
    @Override  
    public String getValue(String dictType, String dictLabel) {  
        Map dict = DICT_DATA.get(dictType);  
        if (dict != null) {  
            for (Map.Entry entry : dict.entrySet()) {  
                if (entry.getValue().equals(dictLabel)) {  
                    return entry.getKey();  
                }            
            }        
        }        
        return dictLabel;  
    }
}

带图片的导出

导出肯定会碰到有图片导出的情况，这种情况也是支持的。主要通过@ExcelImage注解实现。如下代码使用的是生成的base64图片，当然本地图片和图片链接也是支持的。支持给图片设置excel中的默认展示大小和对齐方式。
图片列表也是支持的。
示例代码

@GetMapping("/export")  
@ExportExcel(name = "商品图片列表", sheets = @Sheet(sheetName = "商品信息", clazz = ProductImageDTO.class))  
public List exportWithImages() {  
    List products = new ArrayList<>();  
  
    // 生成示例图片数据（彩色方块）  
    byte[] redImage = generateColorSquare(120, 120, 255, 0, 0); // 红色方块  
    byte[] greenImage = generateColorSquare(80, 80, 0, 255, 0); // 绿色方块  
    byte[] blueImage = generateColorSquare(100, 100, 0, 0, 255); // 蓝色方块  
  
    // 商品1：使用 Base64 图片  
    ProductImageDTO product1 = new ProductImageDTO();  
    product1.setId(1L);  
    product1.setName("iPhone 15 Pro");  
    product1.setPrice(new BigDecimal("7999.00"));  
    product1.setMainImage("data:image/png;base64," + Base64.getEncoder().encodeToString(redImage));  
    product1.setThumbnail(greenImage);  
    product1.setImageList(Arrays.asList("data:image/png;base64," + Base64.getEncoder().encodeToString(blueImage),  
          "data:image/png;base64," + Base64.getEncoder().encodeToString(redImage)));  
    product1.setStock(100);  
    product1.setDescription("最新款 iPhone 15 Pro，A17 Pro 芯片");  
    products.add(product1);  
  
    // 商品2：使用字节数组  
    ProductImageDTO product2 = new ProductImageDTO();  
    product2.setId(2L);  
    product2.setName("MacBook Pro 16");  
    product2.setPrice(new BigDecimal("19999.00"));  
    product2.setMainImage("data:image/png;base64," + Base64.getEncoder().encodeToString(blueImage));  
    product2.setThumbnail(redImage);  
    product2.setImageList(Arrays.asList("data:image/png;base64," + Base64.getEncoder().encodeToString(greenImage),  
          "data:image/png;base64," + Base64.getEncoder().encodeToString(blueImage)));  
    product2.setStock(50);  
    product2.setDescription("16 英寸 MacBook Pro，M3 Max 芯片");  
    products.add(product2);  
  
    // 商品3：使用不同尺寸的图片  
    byte[] largeImage = generateColorSquare(150, 150, 255, 165, 0); // 橙色方块  
    ProductImageDTO product3 = new ProductImageDTO();  
    product3.setId(3L);  
    product3.setName("iPad Air");  
    product3.setPrice(new BigDecimal("4799.00"));  
    product3.setMainImage("data:image/png;base64," + Base64.getEncoder().encodeToString(largeImage));  
    product3.setThumbnail(greenImage);  
    product3.setImageList(Collections.singletonList(  
          "data:image/png;base64," + Base64.getEncoder().encodeToString(redImage)));  
    product3.setStock(200);  
    product3.setDescription("11 英寸 iPad Air，M2 芯片");  
    products.add(product3);  
  
    log.info("Exporting {} products with images", products.size());  
    return products;  
}

话不多说，都在代码里：

@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class ProductImageDTO {  
  
    @ExcelProperty("商品ID")  
    private Long id;  
  
    @ExcelProperty("商品名称")  
    private String name;  
  
    @ExcelProperty("商品价格")  
    private BigDecimal price;  
  
    /**  
     * 商品主图（单张图片）  
     *   
     * 导出时：支持 URL、本地路径、Base64  
     * 导入时：读取为 Base64 字符串  
     * 
  
     */  
    @ExcelProperty("商品主图")  
    @ExcelImage(width = 120, height = 120)  
    private String mainImage;  
  
    /**  
     * 商品缩略图（字节数组）  
     *   
     * 导出时：直接使用字节数组  
     * 导入时：读取为字节数组  
     * 
  
     */  
    @ExcelProperty("商品缩略图")  
    @ExcelImage(width = 80, height = 80, type = ExcelImage.ImageType.BYTES)  
    private byte[] thumbnail;  
  
    /**  
     * 商品图集（多张图片）  
     *   
     * 导出时：支持多张图片水平排列  
     * 导入时：读取为 Base64 字符串列表  
     * 
  
     */  
    @ExcelProperty(value = "商品图集", converter = cn.allbs.excel.convert.ImageListConverter.class)  
    @ExcelImage(width = 100, height = 100)  
    private List imageList;  
  
    @ExcelProperty("库存数量")  
    private Integer stock;  
  
    @ExcelProperty("商品描述")  
    private String description;  
  
}

篇幅有限，有兴趣可以继续看下一篇中更多的应用方式，有些还是挺实用的。下下篇就没啥用处了，下下下篇可以看看。

在群晖上安装appflowy，一个带ai的自托管的云笔记应用，支持多端同步

2025-11-02T10:25:00.000Z

情况说明

群晖923+
docker部署
安装为最新的0.10.3版本，github地址：https://github.com/AppFlowy-IO/AppFlowy
事先安装了postgresql、minio、redis，所以下面docker-compose并没有这两个镜像，而是使用外部库。
理论上需要安装postgres、minio、redis、gotrue、ai（我没用起来，可以不部署）、appflowy-worker、appflowy-web（web端用的，如果只用移动端可以不部署）、appflowy-cloud、appflowy-admin_frontend（我没用起来，可能是配置问题，可以不部署）、nginx（不嫌麻烦的话可以用群晖自带的反向代理，我这里用了）
因为我的console没用起来，所以是直接在配置中先打开了注册，注册完账号后就可以关闭了。
当前应用没有账号密码注册，只有邮箱验证码，所以必须要有一个可以提供邮件发送的smtp配置。
群晖某目录下（无所谓哪个目录）结构为：

首先贴配置

docker-compose

这个没什么，原样贴进去就行，但是当前的端口9999需要根据你自己环境替换，只需改nginx的ports里面的别改多了，后续我继续以9999端口示例。关键的是后面的.env，设计到较多的敏感信息，我会进行过滤，注意进行替换

# Essential services for AppFlowy Cloud

services:
  nginx:
    restart: on-failure
    image: nginx:1.27
    ports:
      - 9999:80   # Disable this if you are using TLS
      #- ${NGINX_TLS_PORT:-443}:443
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      #- ./nginx/ssl/certificate.crt:/etc/nginx/ssl/certificate.crt
      #- ./nginx/ssl/private_key.key:/etc/nginx/ssl/private_key.key
    networks:
      - shared_network
      #- ./nginx_logs:/var/log/nginx

  gotrue:
    restart: on-failure
    image: appflowyinc/gotrue:${GOTRUE_VERSION:-latest}
    healthcheck:
      test: "curl --fail http://127.0.0.1:9999/health || exit 1"
      interval: 5s
      timeout: 5s
      retries: 12
    environment:
      # There are a lot of options to configure GoTrue. You can reference the example config:
      # https://github.com/supabase/auth/blob/master/example.env
      - GOTRUE_ADMIN_EMAIL=${GOTRUE_ADMIN_EMAIL}
      - GOTRUE_ADMIN_PASSWORD=${GOTRUE_ADMIN_PASSWORD}
      - GOTRUE_DISABLE_SIGNUP=${GOTRUE_DISABLE_SIGNUP:-false}
      - GOTRUE_SITE_URL=appflowy-flutter://                           # redirected to AppFlowy application
      - GOTRUE_URI_ALLOW_LIST=**                                      # adjust restrict if necessary
      - GOTRUE_JWT_SECRET=${GOTRUE_JWT_SECRET}                        # authentication secret
      - GOTRUE_JWT_EXP=${GOTRUE_JWT_EXP}
      # Without this environment variable, the createuser command will create an admin
      # with the `admin` role as opposed to `supabase_admin`
      - GOTRUE_JWT_ADMIN_GROUP_NAME=supabase_admin
      - GOTRUE_DB_DRIVER=postgres
      - API_EXTERNAL_URL=${API_EXTERNAL_URL}
      - DATABASE_URL=${GOTRUE_DATABASE_URL}
      - PORT=9999
      - GOTRUE_SMTP_HOST=${GOTRUE_SMTP_HOST}                          # e.g. smtp.gmail.com
      - GOTRUE_SMTP_PORT=${GOTRUE_SMTP_PORT}                          # e.g. 465
      - GOTRUE_SMTP_USER=${GOTRUE_SMTP_USER}                          # email sender, e.g. noreply@appflowy.io
      - GOTRUE_SMTP_PASS=${GOTRUE_SMTP_PASS}                          # email password
      - GOTRUE_MAILER_URLPATHS_CONFIRMATION=/gotrue/verify
      - GOTRUE_MAILER_URLPATHS_INVITE=/gotrue/verify
      - GOTRUE_MAILER_URLPATHS_RECOVERY=/gotrue/verify
      - GOTRUE_MAILER_URLPATHS_EMAIL_CHANGE=/gotrue/verify
      - GOTRUE_SMTP_ADMIN_EMAIL=${GOTRUE_SMTP_ADMIN_EMAIL}                # email with admin privileges e.g. internal@appflowy.io
      - GOTRUE_SMTP_MAX_FREQUENCY=${GOTRUE_SMTP_MAX_FREQUENCY:-1ns}       # set to 1ns for running tests
      - GOTRUE_RATE_LIMIT_EMAIL_SENT=${GOTRUE_RATE_LIMIT_EMAIL_SENT:-100} # number of email sendable per minute
      - GOTRUE_MAILER_AUTOCONFIRM=${GOTRUE_MAILER_AUTOCONFIRM:-false}     # change this to true to skip email confirmation
      # Google OAuth config
      - GOTRUE_EXTERNAL_GOOGLE_ENABLED=${GOTRUE_EXTERNAL_GOOGLE_ENABLED}
      - GOTRUE_EXTERNAL_GOOGLE_CLIENT_ID=${GOTRUE_EXTERNAL_GOOGLE_CLIENT_ID}
      - GOTRUE_EXTERNAL_GOOGLE_SECRET=${GOTRUE_EXTERNAL_GOOGLE_SECRET}
      - GOTRUE_EXTERNAL_GOOGLE_REDIRECT_URI=${GOTRUE_EXTERNAL_GOOGLE_REDIRECT_URI}
      # GITHUB OAuth config
      - GOTRUE_EXTERNAL_GITHUB_ENABLED=${GOTRUE_EXTERNAL_GITHUB_ENABLED}
      - GOTRUE_EXTERNAL_GITHUB_CLIENT_ID=${GOTRUE_EXTERNAL_GITHUB_CLIENT_ID}
      - GOTRUE_EXTERNAL_GITHUB_SECRET=${GOTRUE_EXTERNAL_GITHUB_SECRET}
      - GOTRUE_EXTERNAL_GITHUB_REDIRECT_URI=${GOTRUE_EXTERNAL_GITHUB_REDIRECT_URI}
      # Discord OAuth config
      - GOTRUE_EXTERNAL_DISCORD_ENABLED=${GOTRUE_EXTERNAL_DISCORD_ENABLED}
      - GOTRUE_EXTERNAL_DISCORD_CLIENT_ID=${GOTRUE_EXTERNAL_DISCORD_CLIENT_ID}
      - GOTRUE_EXTERNAL_DISCORD_SECRET=${GOTRUE_EXTERNAL_DISCORD_SECRET}
      - GOTRUE_EXTERNAL_DISCORD_REDIRECT_URI=${GOTRUE_EXTERNAL_DISCORD_REDIRECT_URI}
    networks:
      - shared_network

  appflowy_cloud:
    restart: on-failure
    ports:
      - 18000:8000
    environment:
      - RUST_LOG=${RUST_LOG:-info}
      - APPFLOWY_ENVIRONMENT=production
      - APPFLOWY_DATABASE_URL=${APPFLOWY_DATABASE_URL}
      - APPFLOWY_REDIS_URI=${APPFLOWY_REDIS_URI}
      - APPFLOWY_GOTRUE_JWT_SECRET=${GOTRUE_JWT_SECRET}
      - APPFLOWY_GOTRUE_BASE_URL=${APPFLOWY_GOTRUE_BASE_URL}
      - APPFLOWY_S3_USE_MINIO=${APPFLOWY_S3_USE_MINIO}
      - APPFLOWY_S3_MINIO_URL=${APPFLOWY_S3_MINIO_URL}
      - APPFLOWY_S3_ACCESS_KEY=${APPFLOWY_S3_ACCESS_KEY}
      - APPFLOWY_S3_SECRET_KEY=${APPFLOWY_S3_SECRET_KEY}
      - APPFLOWY_S3_BUCKET=${APPFLOWY_S3_BUCKET}
      - APPFLOWY_S3_REGION=${APPFLOWY_S3_REGION}
      - APPFLOWY_ACCESS_CONTROL=${APPFLOWY_ACCESS_CONTROL}
      # For the CI testing, we set the database connection to 20. The default value is 40.
      - APPFLOWY_DATABASE_MAX_CONNECTIONS=20
      - AI_SERVER_HOST=${AI_SERVER_HOST}
      - AI_SERVER_PORT=${AI_SERVER_PORT}
      - APPFLOWY_WEB_URL=${APPFLOWY_WEB_URL}
      - APPFLOWY_MAILER_SMTP_HOST=${APPFLOWY_MAILER_SMTP_HOST}
      - APPFLOWY_MAILER_SMTP_PORT=${APPFLOWY_MAILER_SMTP_PORT}
      - APPFLOWY_MAILER_SMTP_USERNAME=${APPFLOWY_MAILER_SMTP_USERNAME}
      - APPFLOWY_MAILER_SMTP_EMAIL=${APPFLOWY_MAILER_SMTP_EMAIL}
      - APPFLOWY_MAILER_SMTP_PASSWORD=${APPFLOWY_MAILER_SMTP_PASSWORD}
      - AI_OPENAI_API_KEY=${AI_OPENAI_API_KEY}
    build:
      context: .
      dockerfile: Dockerfile
      args:
        FEATURES: ""
        PROFILE: ci
    networks:
      - shared_network
    image: appflowyinc/appflowy_cloud:${APPFLOWY_CLOUD_VERSION:-latest}
    depends_on:
      gotrue:
        condition: service_healthy

  admin_frontend:
    restart: on-failure
    build:
      context: .
      dockerfile: ./admin_frontend/Dockerfile
    image: appflowyinc/admin_frontend:${APPFLOWY_ADMIN_FRONTEND_VERSION:-latest}
    ports:
      - 13000:3000
    environment:
      - RUST_LOG=${RUST_LOG:-info}
      - ADMIN_FRONTEND_REDIS_URL=${ADMIN_FRONTEND_REDIS_URL:-redis://redis:6379}
      - ADMIN_FRONTEND_GOTRUE_URL=${ADMIN_FRONTEND_GOTRUE_URL:-http://gotrue:9999}
      - ADMIN_FRONTEND_APPFLOWY_CLOUD_URL=${ADMIN_FRONTEND_APPFLOWY_CLOUD_URL:-http://appflowy_cloud:8000}
      - ADMIN_FRONTEND_PATH_PREFIX=${ADMIN_FRONTEND_PATH_PREFIX:-}
    networks:
      - shared_network
    depends_on:
      gotrue:
        condition: service_healthy
      appflowy_cloud:
        condition: service_started

  ai:
    restart: on-failure
    image: appflowyinc/appflowy_ai:${APPFLOWY_AI_VERSION:-latest}
    environment:
      - AI_SERVER_PORT=${AI_SERVER_PORT}
      - OPENAI_API_KEY=${AI_OPENAI_API_KEY}
      - DEFAULT_AI_MODEL=openai/gpt-oss-20b:free # Make sure the model is available in your OpenAI account
      - DEFAULT_AI_COMPLETION_MODEL=openai/gpt-oss-20b:free # Make sure the model is available in your OpenAI account
      - AZURE_OPENAI_API_KEY=${AI_AZURE_OPENAI_API_KEY}
      - AZURE_OPENAI_ENDPOINT=${AI_AZURE_OPENAI_API_BASE}
      - AZURE_OPENAI_API_VERSION=${AI_AZURE_OPENAI_API_VERSION}
      - APPFLOWY_S3_ACCESS_KEY=${APPFLOWY_S3_ACCESS_KEY}
      - APPFLOWY_S3_SECRET_KEY=${APPFLOWY_S3_SECRET_KEY}
      - APPFLOWY_S3_BUCKET=${APPFLOWY_S3_BUCKET}
      - APPFLOWY_S3_REGION=${APPFLOWY_S3_REGION}
      - AI_DATABASE_URL=${APPFLOWY_DATABASE_URL}
      - AI_REDIS_URL=${APPFLOWY_REDIS_URI}
      - AI_USE_MINIO=${APPFLOWY_S3_USE_MINIO}
      - AI_MINIO_URL=${APPFLOWY_S3_MINIO_URL}
      - AI_APPFLOWY_HOST=${APPFLOWY_BASE_URL}
      - APPFLOWY_GOTRUE_JWT_SECRET=${GOTRUE_JWT_SECRET}

  appflowy_worker:
    restart: on-failure
    image: appflowyinc/appflowy_worker:${APPFLOWY_WORKER_VERSION:-latest}
    build:
      context: .
      dockerfile: ./services/appflowy-worker/Dockerfile
    ports:
      - "14001:4001"
    environment:
      - RUST_LOG=${RUST_LOG:-info}
      - APPFLOWY_WORKER_REDIS_URL=${APPFLOWY_WORKER_REDIS_URL:-redis://redis:6379}
      - APPFLOWY_WORKER_ENVIRONMENT=production
      - APPFLOWY_WORKER_DATABASE_URL=${APPFLOWY_WORKER_DATABASE_URL}
      - APPFLOWY_WORKER_DATABASE_NAME=${APPFLOWY_WORKER_DATABASE_NAME}
      - APPFLOWY_S3_USE_MINIO=${APPFLOWY_S3_USE_MINIO}
      - APPFLOWY_S3_MINIO_URL=${APPFLOWY_S3_MINIO_URL}
      - APPFLOWY_S3_ACCESS_KEY=${APPFLOWY_S3_ACCESS_KEY}
      - APPFLOWY_S3_SECRET_KEY=${APPFLOWY_S3_SECRET_KEY}
      - APPFLOWY_S3_BUCKET=${APPFLOWY_S3_BUCKET}
      - APPFLOWY_S3_REGION=${APPFLOWY_S3_REGION}
      - APPFLOWY_MAILER_SMTP_HOST=${APPFLOWY_MAILER_SMTP_HOST}
      - APPFLOWY_MAILER_SMTP_PORT=${APPFLOWY_MAILER_SMTP_PORT}
      - APPFLOWY_MAILER_SMTP_USERNAME=${APPFLOWY_MAILER_SMTP_USERNAME}
      - APPFLOWY_MAILER_SMTP_EMAIL=${APPFLOWY_MAILER_SMTP_EMAIL}
      - APPFLOWY_MAILER_SMTP_PASSWORD=${APPFLOWY_MAILER_SMTP_PASSWORD}
    networks:
      - shared_network
      
  appflowy_web:
    image: appflowyinc/appflowy_web:latest
    environment:
      - APPFLOWY_BASE_URL=${APPFLOWY_BASE_URL}
      - APPFLOWY_GOTRUE_BASE_URL=${APPFLOWY_BASE_URL}/gotrue
      - APPFLOWY_WS_BASE_URL=${APPFLOWY_WEBSOCKET_BASE_URL}
    networks:
      - shared_network

volumes:
  postgres_data:
  minio_data:

networks:
  shared_network:
    name: appflowy_network
    driver: bridge

nginx.conf

events {
    worker_connections 1024;
}

http {
    # docker dns resolver
    resolver 127.0.0.11 valid=10s;
    #error_log /var/log/nginx/error.log debug;

    map $http_upgrade $connection_upgrade {
        default upgrade;
        '' close;
    }

     map $http_origin $cors_origin {
         default $http_origin;
      }

    server {
        listen 8080;

        # https://github.com/nginxinc/nginx-prometheus-exporter
        location = /stub_status {
            stub_status;
        }
    }


    server {
        # ssl_certificate /etc/nginx/ssl/certificate.crt;
        # ssl_certificate_key /etc/nginx/ssl/private_key.key;

        listen 80;
        # listen 443 ssl;
        client_max_body_size 10M;

        underscores_in_headers on;
        set $appflowy_cloud_backend "http://appflowy_cloud:8000";
        set $gotrue_backend "http://gotrue:9999";
        set $appflowy_web_backend "http://appflowy_web:80";

        # GoTrue
        location /gotrue/ {
            proxy_pass $gotrue_backend;

            rewrite ^/gotrue(/.*)$ $1 break;

            # Allow headers like redirect_to to be handed over to the gotrue
            # for correct redirecting
            proxy_set_header Host $http_host;
            proxy_pass_request_headers on;
        }

        # WebSocket
        location /ws {
            # Existing proxy configuration
            proxy_pass $appflowy_cloud_backend;

            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "Upgrade";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_read_timeout 86400s;
        }

        location /api {
            proxy_pass $appflowy_cloud_backend;
            proxy_set_header X-Request-Id $request_id;
            proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;


            location ~* ^/api/workspace/([a-zA-Z0-9_-]+)/publish$ {
                proxy_pass $appflowy_cloud_backend;
                proxy_request_buffering off;
                client_max_body_size 256M;
            }

            # AppFlowy-Cloud
            location /api/chat {
                proxy_pass $appflowy_cloud_backend;

                proxy_http_version 1.1;
                proxy_set_header Connection "";
                chunked_transfer_encoding on;
                proxy_buffering off;
                proxy_cache off;

                proxy_read_timeout 600s;
                proxy_connect_timeout 600s;
                proxy_send_timeout 600s;
            }

            location /api/import {
                proxy_pass $appflowy_cloud_backend;

                # Set headers
                proxy_set_header X-Request-Id $request_id;
                proxy_set_header Host $http_host;

                # Timeouts
                proxy_read_timeout 600s;
                proxy_connect_timeout 600s;
                proxy_send_timeout 600s;

                # Disable buffering for large file uploads
                proxy_request_buffering off;
                proxy_buffering off;
                proxy_cache off;
                client_max_body_size 2G;
            }
        }

        # AppFlowy Web
        location / {
            proxy_pass $appflowy_web_backend;
            proxy_set_header X-Scheme $scheme;
            proxy_set_header Host $host;
        }
    }

}

env

涉及较多的敏感信息需要自行替换。下图的emoji数字即为需要替换的内容，端口如果不是9999环境变量中记得替换。

1️⃣你的域名，ddns到家庭内网的域名
2️⃣postges的内网ip，上面说了库为单独部署，所以需要ip，否则docker可以使用镜像名称识别，redis、minio也是一样，下面不再赘述
3️⃣postgres的用户名
4️⃣postgres的密码
5️⃣postgres的短裤
6️⃣redis的内网ip
7️⃣redis的端口
8️⃣redis的密码
9️⃣minio的内网ip
1️⃣0️⃣minio的上传端口和控制台的端口不一样，一般为9000
1️⃣1️⃣用于控制台的超管邮箱，实际我没用起来
1️⃣2️⃣用于控制台的超管密码，实际我也没用起来
1️⃣3️⃣可以在控制台执行openssl rand -base64 32生成
1️⃣4️⃣你的可用于发送邮件的smtp账号，如果不是谷歌的，需要替换smtp.gmail.com这个内容
1️⃣5️⃣你的可用于发送邮件的smtp账号密码
1️⃣6️⃣你的这个发送邮件的smtp账号的邮箱
1️⃣7️⃣调用大模型的密钥
1️⃣8️⃣调用的大模型

FQDN=1️⃣:9999

SCHEME=https
WS_SCHEME=wss

APPFLOWY_BASE_URL=${SCHEME}://${FQDN}
APPFLOWY_WEBSOCKET_BASE_URL=${WS_SCHEME}://${FQDN}/ws/v2

POSTGRES_HOST=2️⃣
POSTGRES_USER=3️⃣
POSTGRES_PASSWORD=4️⃣
POSTGRES_PORT=5️⃣
POSTGRES_DB=appflowy

# Redis Settings
REDIS_HOST=6️⃣
REDIS_PORT=7️⃣
REDIS_PASSWORD=8️⃣

MINIO_HOST=9️⃣
MINIO_PORT=1️⃣0️⃣
APPFLOWY_GOTRUE_BASE_URL=http://gotrue:9999

APPFLOWY_DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}

APPFLOWY_ACCESS_CONTROL=true

APPFLOWY_WEBSOCKET_MAILBOX_SIZE=6000

APPFLOWY_DATABASE_MAX_CONNECTIONS=40

APPFLOWY_REDIS_URI=redis://:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}

GOTRUE_DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}?search_path=auth

GOTRUE_ADMIN_EMAIL=1️⃣1️⃣
GOTRUE_ADMIN_PASSWORD=1️⃣2️⃣

GOTRUE_JWT_SECRET=1️⃣3️⃣

# Expiration time in seconds for the JWT token
GOTRUE_JWT_EXP=604800

# External URL where the GoTrue service is exposed
API_EXTERNAL_URL=${APPFLOWY_BASE_URL}/gotrue

GOTRUE_MAILER_AUTOCONFIRM=false

# Set this to true if users can only join by invite
GOTRUE_DISABLE_SIGNUP=true

# Number of emails that can be sent per minute
GOTRUE_RATE_LIMIT_EMAIL_SENT=100

GOTRUE_MAILER_TEMPLATES_MAGIC_LINK=

ADMIN_FRONTEND_REDIS_URL=redis://:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}

# URL that connects to gotrue docker container
ADMIN_FRONTEND_GOTRUE_URL=http://gotrue:9999

# URL that connects to the cloud docker container
ADMIN_FRONTEND_APPFLOWY_CLOUD_URL=http://appflowy_cloud:8000

GOTRUE_SMTP_HOST=smtp.gmail.com
GOTRUE_SMTP_PORT=465
GOTRUE_SMTP_USER=1️⃣4️⃣
GOTRUE_SMTP_PASS=1️⃣5️⃣
GOTRUE_SMTP_ADMIN_EMAIL=1️⃣6️⃣

# AppFlowy Cloud Mailer
# Note that smtps (TLS) is always required, even for ports other than 465
APPFLOWY_MAILER_SMTP_HOST=smtp.gmail.com
APPFLOWY_MAILER_SMTP_PORT=465
APPFLOWY_MAILER_SMTP_USERNAME=1️⃣4️⃣
APPFLOWY_MAILER_SMTP_EMAIL=1️⃣6️⃣
APPFLOWY_MAILER_SMTP_PASSWORD=1️⃣5️⃣
APPFLOWY_MAILER_SMTP_TLS_KIND=wrapper # "none" "wrapper" "required" "opportunistic"
GOTRUE_EXTERNAL_GOOGLE_ENABLED=false
GOTRUE_EXTERNAL_GOOGLE_CLIENT_ID=
GOTRUE_EXTERNAL_GOOGLE_SECRET=
GOTRUE_EXTERNAL_GOOGLE_REDIRECT_URI=${API_EXTERNAL_URL}/callback

# GitHub OAuth2
GOTRUE_EXTERNAL_GITHUB_ENABLED=false
GOTRUE_EXTERNAL_GITHUB_CLIENT_ID=
GOTRUE_EXTERNAL_GITHUB_SECRET=
GOTRUE_EXTERNAL_GITHUB_REDIRECT_URI=${API_EXTERNAL_URL}/callback

# Discord OAuth2
GOTRUE_EXTERNAL_DISCORD_ENABLED=false
GOTRUE_EXTERNAL_DISCORD_CLIENT_ID=
GOTRUE_EXTERNAL_DISCORD_SECRET=
GOTRUE_EXTERNAL_DISCORD_REDIRECT_URI=${API_EXTERNAL_URL}/callback

# Apple OAuth2
GOTRUE_EXTERNAL_APPLE_ENABLED=false
GOTRUE_EXTERNAL_APPLE_CLIENT_ID=
GOTRUE_EXTERNAL_APPLE_SECRET=
GOTRUE_EXTERNAL_APPLE_REDIRECT_URI=${API_EXTERNAL_URL}/callback

# SAML 2.0. Refer to https://github.com/AppFlowy-IO/AppFlowy-Cloud/blob/main/doc/OKTA_SAML.md for example using Okta.
GOTRUE_SAML_ENABLED=false
GOTRUE_SAML_PRIVATE_KEY=

APPFLOWY_S3_USE_MINIO=true

APPFLOWY_S3_CREATE_BUCKET=true

APPFLOWY_S3_MINIO_URL=http://${MINIO_HOST}:${MINIO_PORT}

APPFLOWY_S3_ACCESS_KEY=${AWS_ACCESS_KEY}
APPFLOWY_S3_SECRET_KEY=${AWS_SECRET}

APPFLOWY_S3_BUCKET=appflowy

APPFLOWY_S3_REGION=us-east-1

AI_OPENAI_API_KEY=1️⃣7️⃣

# If no summary model is provided, there will be no search summary when using AI search.
AI_OPENAI_API_SUMMARY_MODEL=1️⃣9️⃣

AI_AZURE_OPENAI_API_KEY=1️⃣7️⃣
AI_AZURE_OPENAI_API_BASE=1️⃣8️⃣
AI_AZURE_OPENAI_API_VERSION=1️⃣9️⃣

# AI Service Configuration (Docker container defaults)
AI_SERVER_PORT=5001
AI_SERVER_HOST=ai
AI_DATABASE_URL=postgresql+psycopg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
AI_REDIS_URL=redis://${REDIS_HOST}:${REDIS_PORT}
AI_APPFLOWY_BUCKET_NAME=${APPFLOWY_S3_BUCKET}
AI_APPFLOWY_HOST=${APPFLOWY_BASE_URL}
AI_MINIO_URL=http://${MINIO_HOST}:${MINIO_PORT}

# Embedding Configuration
APPFLOWY_EMBEDDING_CHUNK_SIZE=2000
APPFLOWY_EMBEDDING_CHUNK_OVERLAP=200

# =============================================================================
# ⚙️ WORKER SERVICES: Background processing (good defaults for production)
# =============================================================================

# AppFlowy Indexer (for search functionality)
APPFLOWY_INDEXER_ENABLED=true
APPFLOWY_INDEXER_DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
APPFLOWY_INDEXER_REDIS_URL=redis://:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}
APPFLOWY_INDEXER_EMBEDDING_BUFFER_SIZE=5000

APPFLOWY_COLLABORATE_MULTI_THREAD=false

APPFLOWY_COLLABORATE_REMOVE_BATCH_SIZE=100

# AppFlowy Worker Service
APPFLOWY_WORKER_REDIS_URL=redis://:${REDIS_PASSWORD}@${REDIS_HOST}:${REDIS_PORT}
APPFLOWY_WORKER_DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
APPFLOWY_WORKER_DATABASE_NAME=${POSTGRES_DB}

# =============================================================================
# 🌐 WEB FRONTEND: AppFlowy Web interface
# =============================================================================

# AppFlowy Web
# If your AppFlowy Web is hosted on a different domain, update this variable to the correct domain
APPFLOWY_WEB_URL=${APPFLOWY_BASE_URL}

# If you are running AppFlowy Web locally for development purpose, use the following value instead
APPFLOWY_WEB_URL=https://1️⃣:9999

NGINX_PORT=9999
NGINX_TLS_PORT=18443

RUST_LOG=info

CLOUDFLARE_TUNNEL_TOKEN=

AI_TEST_ENABLED=true
ADMIN_FRONTEND_PATH_PREFIX=/console

导入docker-compose并构建启动

群晖的反向代理

以防万一配置一些自定义标题，这些是我在尝试过程中解决问题添加的，没去试最后成功后这些是否还有作用。

最后是路由器的端口映射

成果

这篇文章就是使用的自部署的appflowy写的，移动端如果是苹果的话需要用外网账号下载，修改配置需要重启软件，还会卡很久。PS:我是第一次见一个手机app可以卡这么久的（绝对比你想象的要久），说明**进步空间**巨大。

在把qq表情包弄到微信中时，发现了百度网盘整的烂活

2025-07-25T03:53:45.000Z

昨天弄到一套qq的动态表情包，这样的：

因为是用百度网盘分享的，所以随即下载了一个百度网盘。

对了如果有需要的通过小程序自取(可以保存到手机相册，然后添加到微信的表情包)，在小程序的这个位置：：

但是出现了一个奇怪的问题，每次浏览电脑图片时，莫名发现百度网盘居然会启动！

然后仔细观察了一下发现，右键菜单居然多了一个默认选项：

说实话开始压根没有把他们联想起来，重复几次查看图片网盘重启后有点回过味了，于是开始一通找，找到选项如下：

不得不说百度的产品经理真tm是个鬼才，居然还能想到这种方法来保证用户的活跃…

使用everything大概找了一下：

既然直到名称就好办了

写个脚本清除掉好了,新建文本文档重命名为remove_baidu_imageviewer.ps1这是一个powershell脚本，有对应的后缀名！对了我这个脚本比较激进，直接移除类似的文件和注册表、移除右键选项、还原默认图片打开方式、并创建了锁文件防止百度网盘再次生成。脚本比较激进！不确认会不会有其他影响，慎用！可参考！

<#
.SYNOPSIS
  百度网盘“智能看图”功能一键清理脚本（当前用户）

.DESCRIPTION
  - 杀掉相关进程
  - 删除程序目录和缓存目录
  - 删除注册表残留
  - 清理“打开方式”列表中的智能看图条目
  - 可选恢复图片默认打开方式
  - 可选创建锁文件，阻止目录再次生成

.NOTES
  请以管理员身份运行！
#>

# ------------------------ 配置区 ------------------------
# 是否恢复默认打开方式（默认 false）
$RestoreAssoc = $false

# 要恢复的扩展名和 ProgId (Win11 照片常见 ProgId，可能不同版本不同)
$ImageExts = '.jpg','.jpeg','.png','.gif','.bmp','.webp','.tif','.tiff','.heic'
$ProgId    = 'AppX4hxtad77fbk3jkkeerkrm0ze94wjf3s9'

# 防止再次生成的目录（用“锁文件”占位）
$LockTargets = @(
  (Join-Path $env:APPDATA      'baidu\BaiduNetdisk\module\ImageViewer')
  # 如有需要可加入 Temp 缓存目录，但 Temp 本身会清理，不建议锁死
  # (Join-Path $env:LOCALAPPDATA 'Temp\baidu\ImageViewer')
)

# OpenWith 清理时用于匹配的关键字
$Keywords = 'baidu','imageviewer','smartpic','bdimageviewer','baidunetdiskimageviewer'
# --------------------------------------------------------

Write-Host "========== 百度网盘“智能看图”卸载脚本 =========="
Write-Host "请确认以管理员身份运行..." -ForegroundColor Yellow
Write-Host

# 1. 结束相关进程
Write-Host "[1/6] 结束相关进程..."
taskkill /F /IM ImageViewer.exe    2>$null
taskkill /F /IM BaiduNetdisk*.exe  2>$null

# 2. 删除目录
Write-Host "[2/6] 删除程序目录..."
$DelPaths = @(
  (Join-Path $env:APPDATA      'baidu\BaiduNetdisk\module\ImageViewer'),
  (Join-Path $env:LOCALAPPDATA 'Temp\baidu\ImageViewer')
)
foreach ($p in $DelPaths) {
  if (Test-Path $p) {
    try {
      Remove-Item -Recurse -Force $p
      Write-Host "  √ 删除: $p"
    } catch {
      Write-Warning "  × 删除失败，请手动删除或确认无进程占用: $p"
    }
  } else {
    Write-Host "  (已不存在) $p"
  }
}

# 3. 删除注册表项
Write-Host "[3/6] 删除注册表项..."
$RegToDelete = @(
  'HKCR\BaiduNetdiskImageViewerAssociations',
  'HKCU\Software\Baidu\BaiduNetdiskImageViewer',
  'HKCU\Software\Baidu\BaiduNetdisk\ImageViewer',
  'HKCU\Software\Classes\bdimageviewer',
  'HKCU\Software\Classes\bdsmartpic',
  'HKCU\Software\Classes\Applications\ImageViewer.exe',
  'HKCU\Software\Classes\Applications\bdimageviewer.exe',
  'HKCR\bdimageviewer',
  'HKCR\bdsmartpic',
  'HKCR\*\shell\BaiduSmartPic',
  'HKCR\Directory\shell\BaiduSmartPic',
  'HKCR\SystemFileAssociations\.jpg\shell\BaiduSmartPic'
)

foreach ($rk in $RegToDelete) {
  reg delete "$rk" /f >nul 2>&1
  if ($LASTEXITCODE -eq 0) {
    Write-Host "  √ 删除 $rk"
  } else {
    Write-Host "  (不存在或已删除) $rk"
  }
}

# HKCU\Software\RegisteredApplications\BaiduNetdiskImageViewer (删除值)
reg delete "HKCU\Software\RegisteredApplications" /v "BaiduNetdiskImageViewer" /f >nul 2>&1
if ($LASTEXITCODE -eq 0) {
  Write-Host "  √ 删除 RegisteredApplications 中的 BaiduNetdiskImageViewer"
} else {
  Write-Host "  (不存在或已删除) RegisteredApplications 中的 BaiduNetdiskImageViewer"
}

# 4. 从打开方式列表剔除智能看图
Write-Host "[4/6] 清理“打开方式”列表中残留..."
foreach ($ext in $ImageExts) {
  $base = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts\$ext"
  $owList = Join-Path $base 'OpenWithList'
  $owProg = Join-Path $base 'OpenWithProgids'

  # OpenWithList
  if (Test-Path $owList) {
    $props = (Get-ItemProperty $owList).psobject.Properties |
             Where-Object { $_.Name -match '^[a-z]$' } # a,b,c...
    foreach ($p in $props) {
      if ($p.Value -match ($Keywords -join '|')) {
        Write-Host "  [$ext] 移除 OpenWithList: $($p.Name)=$($p.Value)"
        Remove-ItemProperty -Path $owList -Name $p.Name -Force
      }
    }
    # 修复 MRUList
    $mru = (Get-ItemProperty $owList -Name 'MRUList' -ErrorAction SilentlyContinue).MRUList
    if ($mru) {
      $valid = ($mru.ToCharArray() | Where-Object { Test-Path ("$owList\$_") }) -join ''
      Set-ItemProperty -Path $owList -Name 'MRUList' -Value $valid -Force
    }
  }

  # OpenWithProgids
  if (Test-Path $owProg) {
    $props = (Get-ItemProperty $owProg).psobject.Properties |
             Where-Object { $_.Name -notmatch '^PS(Path|ParentPath|ChildName|Drive|Provider)$' }
    foreach ($p in $props) {
      if ($p.Name -match ($Keywords -join '|')) {
        Write-Host "  [$ext] 移除 OpenWithProgids: $($p.Name)"
        Remove-ItemProperty -Path $owProg -Name $p.Name -Force
      }
    }
  }
}

# 5. 可选恢复默认打开方式
if ($RestoreAssoc) {
  Write-Host "[5/6] 恢复默认打开方式 -> $ProgId"
  foreach ($ext in $ImageExts) {
    $path = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts\$ext\UserChoice"
    if (Test-Path $path) { Remove-Item $path -Recurse -Force }
    New-Item $path -Force | Out-Null
    New-ItemProperty -Path $path -Name 'ProgId' -Value $ProgId -Force | Out-Null
  }
}

# 6. 创建锁文件防止再次生成
Write-Host "[6/6] 创建锁文件防止目录再生..."
foreach ($t in $LockTargets) {
  try {
    if (Test-Path $t) {
      if ((Get-Item $t).PSIsContainer) {
        Remove-Item -Recurse -Force $t
      } else {
        attrib +R $t
        Write-Host "  (已存在锁文件) $t"
        continue
      }
    }
    New-Item $t -ItemType File -Force | Out-Null
    attrib +R $t
    Write-Host "  √ Locked: $t"
  } catch {
    Write-Warning "  × 无法锁定 $t：$($_.Exception.Message)"
  }
}

Write-Host
Write-Host "========== 完成 =========="
Write-Host "建议重启资源管理器或重启电脑以确保所有更改生效。"
Write-Host "如仍在“打开方式”出现残留，可手动检查上述注册表路径或反馈我继续调整。" -ForegroundColor Yellow

运行后可以看到选项已删除：

使用claude code + cloudflare上线一个工具下载说明站

2025-07-23T07:30:00.000Z

本文是一个完整的建站、部署示例，不需要懂任何代码，在十分钟内可以上线一个属于自己的网站，供所有人进行访问。

这个网站可以是博客、外贸网站、游戏网站等等，流程都一样，区别只是内容。

有需要使用influxdb连接工具的可以试试我正在做的这个软件，全平台分发，几兆体积。不过正在做，不少功能没完善。

将要使用的工具

我采用的是Claude Code + github + cloudflare作为整个流程的支撑工具。国内Claude Code完全无法使用，github间歇性可以使用，cloudflare正常使用，所以没有科学手段的同学可以采用刚出的阿里的Qwen Code来代替Claude Code。

或者采用完全国内无门槛的工具集合——Qwen Code + gitee + 腾讯云的pages。

前景提要

首先我需要继续声明一点，我这个示例内容是一个工具下载网站。我最近写了一个influxdb的连接工具，这个网站就是用来做展示和下载。和你们想要实现的内容完全不同，你需要在实现过程中按照你的想法修改提示词。

网站示例：https://inflowave.kkape.com/

实现流程

使用提示词开始创建网站

我在工具代码文件夹启用Claude Code，并使用自然语言告诉它：

它会帮你分析你所提供的材料并自动生成todo List后逐步实现：

期间会一项项进行实现：

你只需要安心等待一会会发现它完成了创建:

使用github进行管理

既然项目已经创建为了后续的部署操作，你需要在代码库中托管，可以是github，也可以是gitee。

创建一个空的仓库并拷贝其中的仓库地址。

将空仓库的地址复制并继续让Claude Code提交代码并推送至远程，红框内就是我输入的提示词。

完善网站内容并推送代码

到这一步其实你已经完成了项目的创建，已经完全可以上线这个网站了。但是考虑到第一次输入的提示词内容过于简短，所以我多增加了一些内容让其完善。分别为：

完善i18n，也就是常说的中英文切换，做外贸网站会需要，国内用户使用可以忽略。
检测用户设备，直接推荐用户下载符合当前设备的安装包。

继续告诉它哪些区域缺少了i18n让他继续完善，不需要中英文切换的读者可以忽略。

最后就是推送修改后的代码。

部署发布网站

既然网站已经开发完成并已经推送到了仓库中，那么就可以选择上线这个网站，如果你没有域名完全可以使用github提供的pages功能部署。考虑到我需要使用自己的域名，所以后续采用的是cloudflare部署并发布。

部署发布

Cloudflare人称赛博菩萨、赛博活佛，以免费提供ddos防护出名，实际上祂提供大量的免费云服务，比如R2免费云储存、KV库、免费Workers和Pages等，这里部署网站使用的就是Pages功能。

打开cloudflare

https://dash.cloudflare.com/login

找到workers and pages

创建一个pages，前文推送到github的远程仓库就是为了在这里使用。

如果没有关联github，先关联账号。然后将你需要部署的这个仓库单独给cloudflare权限。

选择一个库后点击开始设置。输入对应的构建命令和构建输出目录，基本都是这俩内容。一个npm run build一个dist

如果你输入这些无法构建，找一下Claude Code给的说明即可：

这里可以看到生产版本构建的指令和上方输入指令是可以对上的。

至于下方部署到各平台脚本也可以使用，效果和使用cloudflare效果是一样的，区别只是使用的服务商不同。

最后就是指定自己的网站访问该服务：

在你部署之后有一个自定义域的选项

这个自定义域可以是直接的二级域名，我下面设置的是三级域名，毕竟二级域名还在用没空出来。也就是你看到的inflowave.kkape.com输入后点击继续即可。

网站一览

因为提示词不多，所以内容还是较为朴素的，你完全可以指示它继续打磨。

kkfileview漏洞修复及加固

2025-07-04T03:02:00.000Z

小程序很久之前出过一个功能——文件在线预览。功能是在小程序中直接打开word、excel、压缩包等等在微信中无法打开的文件。

然后前几天突然看到一封邮件。

然后上去看了一下，发现还真有人拿我的网站搞色色。上面这个链接现在肯定也失效了，大家就不要去试了，内容大概是这种东西(可能有些人会觉得眼熟)：

这个功能使用的是开源项目kkfileview(https://github.com/kekingcn/kkFileView)进行实现，我是用docker部署了4.1.0版本。

4.1.0不是最新版本，想使用最新版本，需要加他们的星球，99块一位。当然也自行打包，源码完全提供。

项目部署一开始我就在nginx中禁用了上传，以为是程序漏洞，日志太多懒得翻，所以干脆fork了一下他们的代码，重新打包到我自己的docker镜像库，并拉取替换了本地部署。

重点来了

昨天上班特意观察了一下：

发现压根不是上传接口的漏而是用了SSRF + 存储型 XSS 组合漏洞。服务器替攻击者下载并缓存了远程 HTML，kkFileView然后把下载结果放到自己的静态目录，再用 iframe/iframe-like 方式渲染，攻击文件就拥有了与服务同源的执行环境，只能说幸好是docker部署的。

后续就是把代码改了下加了几个功能：

危险文件类型过滤，比如HTML、JS、PHP等潜在有害的文件类型。
域名白名单控制，限制只能访问可信域名的文件。
内容安全扫描，阻止文件中可能存在的恶意内容
安全日志记录，对日志中的敏感URL进行脱敏处理
github workflow自动化构建，修改版本号并提交git时，会自动打amd、arm架构的包推送到docker和github的镜像库。

修改后的代码地址：https://github.com/chenqi92/kkFileView

修改后的docker镜像：kkape/kkfileview:latest

今天看了下日志

对方果然还在尝试，不过也没成功就是了。

查了下攻击者

这个域名xtdrug——系统毒药，说实话感觉就不是奔着正经用途去的。

几种可能：

他们在搞灰产
他们系统也被黑客被入侵了。
域名不是他们的，但是忘记注销备案了。也是基于这一点我打了个码。

无需服务器部署网站

2025-05-27T02:12:00.000Z

Serverless

很多人都用过cloudflare的workers and pages，无需服务器即可架设自己的网站。cloudflare的如下：

现在腾讯也有类似的功能了。下面就讲一下如何进行部署使用。

Edge One

1.在腾讯云的控制台中找到这个功能：

2.开通功能

可以看到有三种方式进行部署

1️⃣导入git仓库，也就是直接使用你github或者gitee仓库中的项目来部署

2️⃣使用模板，从若干中腾讯提供的网站模板中一键部署，具体想要什么样的网站可以从模板中选择

3️⃣直接上传，也就是类似于nginx反代的静态目录

具体使用

考虑到2️⃣和3️⃣没有啥操作空间，所以我就展示第一种。

连接github，gitee一样的，只展示github

点击连接github会弹出github授权，直接同意即可。

只选择自己想要部署的项目为例，我这里以我的博客项目示例

导入仓库

上述内容实际是我为了演示，用的新号做的演示，后续内容继续使用那个号无法继续，所以我就切回来了继续进行演示。上一步选择库并save之后如下图。我会演示两种，一种是我的博客hexo的（这种需要多安装一个hexo所以加了一下），一种是很常见的前端部署流程。

第一个，带其他框架，编译和安装命令不同于常规项目

这种情况下需要额外安装hexo，并用hexo进行打包，所以说有稍许不同。完成后点击开始部署即可。

第二个，常规的打包，注意区分输出目录，很多人可能会问，明明是常规的打包为什么要特意讲还放在后面

这个特殊点在于国内的镜像并不是所有都能下下来的，所以得变通一下手段，以下是常规打包方式，除了输出目录没什么特别的。

如果不进行变通直接部署会出现下面错误情况：

所以你得变通一下

设置部署命令前先安装pnpm，再用pnpm进行安装，虽然和第一种类似，我怕有些朋友没想到这种方法，所以单列出来。

最后，配置自定义域名

腾讯提供的默认预览地址只有3小时，这也跟国内的域名要备案有关，所以得设置自定义的域名。

点击自定义域名的链接进行配置

最后在域名里面配置自定义解析即可。

功能对比

首先是我的博客访问地址，因为是静态内容，所以访问没什么问题

其次是上面的第二格示例访问地址news.allbs.cn，考虑到没啥用已关，是一个新闻热榜聚合网站，本来是想看看会不会加载到国外网站的

没想到直接全部没法访问，看来腾讯还是对pages功能做了限制。

最后是同样使用pages部署的这个新闻聚合网站,访问地址点击查看，区别是部署在cloudflare上

docker制作国内代理镜像的两种方法

2025-05-14T09:15:00.000Z

方式一：无海外VPS

借助cloudflare的Workers 和 Pages创建workers

输入相应的代码并替换其中的域名

首先点击编辑代码。
将下面的代码输入并修改其中的域名。
将下面你的域名几个字替换为你自己的实际域名，比如playdemo.app或者子域hub.playdemo.app之类的。

// Docker镜像仓库主机地址
let hub_host = 'registry-1.docker.io';
// Docker认证服务器地址
const auth_url = 'https://auth.docker.io';
const workers_url = 'https://你的域名';

let 屏蔽爬虫UA = ['netcraft'];

// 根据主机名选择对应的上游地址
function routeByHosts(host) {
// 定义路由表
const routes = {
// 生产环境
"quay": "quay.io",
"gcr": "gcr.io",
"k8s-gcr": "k8s.gcr.io",
"k8s": "registry.k8s.io",
"ghcr": "ghcr.io",
"cloudsmith": "docker.cloudsmith.io",
"nvcr": "nvcr.io",

// 测试环境
"test": "registry-1.docker.io",
};

if (host in routes) return [routes[host], false];
else return [hub_host, true];
}

/** @type {RequestInit} */
const PREFLIGHT_INIT = {
// 预检请求配置
headers: new Headers({
'access-control-allow-origin': '*', // 允许所有来源
'access-control-allow-methods': 'GET,POST,PUT,PATCH,TRACE,DELETE,HEAD,OPTIONS', // 允许的HTTP方法
'access-control-max-age': '1728000', // 预检请求的缓存时间
}),
}

/**
 * 构造响应
 * @param {any} body 响应体
 * @param {number} status 响应状态码
 * @param {Object} headers 响应头
 */
function makeRes(body, status = 200, headers = {}) {
headers['access-control-allow-origin'] = '*' // 允许所有来源
return new Response(body, { status, headers }) // 返回新构造的响应
}

/**
 * 构造新的URL对象
 * @param {string} urlStr URL字符串
 * @param {string} base URL base
 */
function newUrl(urlStr, base) {
try {
console.log(`Constructing new URL object with path ${urlStr} and base ${base}`);
return new URL(urlStr, base); // 尝试构造新的URL对象
} catch (err) {
console.error(err);
return null // 构造失败返回null
}
}

async function nginx() {
const text = `



Welcome to nginx!



Welcome to nginx!
If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.

For online documentation and support please refer to
nginx.org.

Commercial support is available at
nginx.com.

Thank you for using nginx.


`
return text;
}

async function searchInterface() {
const html = `



Docker Hub 镜像搜索



















Docker Hub 镜像搜索
快速查找、下载和部署 Docker 容器镜像




提示：按回车键快速搜索




`;
return html;
}

export default {
async fetch(request, env, ctx) {
const getReqHeader = (key) => request.headers.get(key); // 获取请求头

let url = new URL(request.url); // 解析请求URL
const userAgentHeader = request.headers.get('User-Agent');
const userAgent = userAgentHeader ? userAgentHeader.toLowerCase() : "null";
if (env.UA) 屏蔽爬虫UA = 屏蔽爬虫UA.concat(await ADD(env.UA));
const workers_url = `https://${url.hostname}`;

// 获取请求参数中的 ns
const ns = url.searchParams.get('ns');
const hostname = url.searchParams.get('hubhost') || url.hostname;
const hostTop = hostname.split('.')[0]; // 获取主机名的第一部分

let checkHost; // 在这里定义 checkHost 变量
// 如果存在 ns 参数，优先使用它来确定 hub_host
if (ns) {
if (ns === 'docker.io') {
hub_host = 'registry-1.docker.io'; // 设置上游地址为 registry-1.docker.io
} else {
hub_host = ns; // 直接使用 ns 作为 hub_host
}
} else {
checkHost = routeByHosts(hostTop);
hub_host = checkHost[0]; // 获取上游地址
}

const fakePage = checkHost ? checkHost[1] : false; // 确保 fakePage 不为 undefined
console.log(`域名头部: ${hostTop} 反代地址: ${hub_host} searchInterface: ${fakePage}`);
// 更改请求的主机名
url.hostname = hub_host;
const hubParams = ['/v1/search', '/v1/repositories'];
if (屏蔽爬虫UA.some(fxxk => userAgent.includes(fxxk)) && 屏蔽爬虫UA.length > 0) {
// 首页改成一个nginx伪装页
return new Response(await nginx(), {
headers: {
'Content-Type': 'text/html; charset=UTF-8',
},
});
} else if ((userAgent && userAgent.includes('mozilla')) || hubParams.some(param => url.pathname.includes(param))) {
if (url.pathname == '/') {
if (env.URL302) {
return Response.redirect(env.URL302, 302);
} else if (env.URL) {
if (env.URL.toLowerCase() == 'nginx') {
//首页改成一个nginx伪装页
return new Response(await nginx(), {
headers: {
'Content-Type': 'text/html; charset=UTF-8',
},
});
} else return fetch(new Request(env.URL, request));
} else{
if (fakePage) return new Response(await searchInterface(), {
headers: {
'Content-Type': 'text/html; charset=UTF-8',
},
});
}
} else {
if (fakePage) url.hostname = 'registry.hub.docker.com';
if (url.searchParams.get('q')?.includes('library/') && url.searchParams.get('q') != 'library/') {
const search = url.searchParams.get('q');
url.searchParams.set('q', search.replace('library/', ''));
}
const newRequest = new Request(url, request);
return fetch(newRequest);
}
}

// 修改包含 %2F 和 %3A 的请求
if (!/%2F/.test(url.search) && /%3A/.test(url.toString())) {
let modifiedUrl = url.toString().replace(/%3A(?=.*?&)/, '%3Alibrary%2F');
url = new URL(modifiedUrl);
console.log(`handle_url: ${url}`);
}

// 处理token请求
if (url.pathname.includes('/token')) {
let token_parameter = {
headers: {
'Host': 'auth.docker.io',
'User-Agent': getReqHeader("User-Agent"),
'Accept': getReqHeader("Accept"),
'Accept-Language': getReqHeader("Accept-Language"),
'Accept-Encoding': getReqHeader("Accept-Encoding"),
'Connection': 'keep-alive',
'Cache-Control': 'max-age=0'
}
};
let token_url = auth_url + url.pathname + url.search;
return fetch(new Request(token_url, request), token_parameter);
}

// 修改 /v2/ 请求路径
if (hub_host == 'registry-1.docker.io' && /^\/v2\/[^/]+\/[^/]+\/[^/]+$/.test(url.pathname) && !/^\/v2\/library/.test(url.pathname)) {
//url.pathname = url.pathname.replace(/\/v2\//, '/v2/library/');
url.pathname = '/v2/library/' + url.pathname.split('/v2/')[1];
console.log(`modified_url: ${url.pathname}`);
}

// 构造请求参数
let parameter = {
headers: {
'Host': hub_host,
'User-Agent': getReqHeader("User-Agent"),
'Accept': getReqHeader("Accept"),
'Accept-Language': getReqHeader("Accept-Language"),
'Accept-Encoding': getReqHeader("Accept-Encoding"),
'Connection': 'keep-alive',
'Cache-Control': 'max-age=0'
},
cacheTtl: 3600 // 缓存时间
};

// 添加Authorization头
if (request.headers.has("Authorization")) {
parameter.headers.Authorization = getReqHeader("Authorization");
}

// 添加可能存在字段X-Amz-Content-Sha256
if (request.headers.has("X-Amz-Content-Sha256")) {
parameter.headers['X-Amz-Content-Sha256'] = getReqHeader("X-Amz-Content-Sha256");
}

// 发起请求并处理响应
let original_response = await fetch(new Request(url, request), parameter);
let original_response_clone = original_response.clone();
let original_text = original_response_clone.body;
let response_headers = original_response.headers;
let new_response_headers = new Headers(response_headers);
let status = original_response.status;

// 修改 Www-Authenticate 头
if (new_response_headers.get("Www-Authenticate")) {
let auth = new_response_headers.get("Www-Authenticate");
let re = new RegExp(auth_url, 'g');
new_response_headers.set("Www-Authenticate", response_headers.get("Www-Authenticate").replace(re, workers_url));
}

// 处理重定向
if (new_response_headers.get("Location")) {
const location = new_response_headers.get("Location");
console.info(`Found redirection location, redirecting to ${location}`);
return httpHandler(request, location, hub_host);
}

// 返回修改后的响应
let response = new Response(original_text, {
status,
headers: new_response_headers
});
return response;
}
};

/**
 * 处理HTTP请求
 * @param {Request} req 请求对象
 * @param {string} pathname 请求路径
 * @param {string} baseHost 基地址
 */
function httpHandler(req, pathname, baseHost) {
const reqHdrRaw = req.headers;

// 处理预检请求
if (req.method === 'OPTIONS' &&
reqHdrRaw.has('access-control-request-headers')
) {
return new Response(null, PREFLIGHT_INIT);
}

let rawLen = '';

const reqHdrNew = new Headers(reqHdrRaw);

const refer = reqHdrNew.get('referer');

let urlStr = pathname;

const urlObj = newUrl(urlStr, 'https://' + baseHost);

/** @type {RequestInit} */
const reqInit = {
method: req.method,
headers: reqHdrNew,
redirect: 'follow',
body: req.body
};
return proxy(urlObj, reqInit, rawLen);
}

/**
 * 代理请求
 * @param {URL} urlObj URL对象
 * @param {RequestInit} reqInit 请求初始化对象
 * @param {string} rawLen 原始长度
 */
async function proxy(urlObj, reqInit, rawLen) {
const res = await fetch(urlObj.href, reqInit);
const resHdrOld = res.headers;
const resHdrNew = new Headers(resHdrOld);

// 验证长度
if (rawLen) {
const newLen = resHdrOld.get('content-length') || '';
const badLen = (rawLen !== newLen);

if (badLen) {
return makeRes(res.body, 400, {
'--error': `bad len: ${newLen}, except: ${rawLen}`,
'access-control-expose-headers': '--error',
});
}
}
const status = res.status;
resHdrNew.set('access-control-expose-headers', '*');
resHdrNew.set('access-control-allow-origin', '*');
resHdrNew.set('Cache-Control', 'max-age=1500');

// 删除不必要的头
resHdrNew.delete('content-security-policy');
resHdrNew.delete('content-security-policy-report-only');
resHdrNew.delete('clear-site-data');

return new Response(res.body, {
status,
headers: resHdrNew
});
}

async function ADD(envadd) {
var addtext = envadd.replace(/[ |"'\r\n]+/g, ',').replace(/,+/g, ',');// 将空格、双引号、单引号和换行符替换为逗号
if (addtext.charAt(0) == ',') addtext = addtext.slice(1);
if (addtext.charAt(addtext.length - 1) == ',') addtext = addtext.slice(0, addtext.length - 1);
const add = addtext.split(',');
return add;
}

点击部署

配置自定义的域名

点击左上角的箭头返回。
点击设置。
域和路由->点击添加
添加自定义的域
测试

上述两项测试通过，说明可以正常使用。

方式二：有海外VPS

首先登录你们的海外vps

在目录/etc/docker/registry目录下创建config.yml

1
2
3

cd /etc/docker
mkdir registry
nano config.yml

输入以下内容：

1 2	proxy: remoteurl: https://registry-1.docker.io

使用docker跑镜像

在一个你喜欢的目录配置镜像相关的文件映射。
比如我喜欢在/mnt目录中进行操作，那么会创建一个文件夹用于映射镜像相关配置和一个docker-compose.yml
registry中也配置一个config.yml，内容完善一点，比如如下：

version: 0.1
storage:
  cache:
    blobdescriptor: inmemory   # 内存缓存 blob 描述符
  filesystem:
    rootdirectory: /mnt/registry  # 本地存储目录
http:
  addr: :5000
proxy:
  remoteurl: https://registry-1.docker.io  # Docker Hub 上游
delete:
  enabled: true  # 定期清理过期数据

配置docker-compose.yml

services:
  registry:
    image: registry:2            # 官方 Registry 镜像
    restart: always
    ports:
      - "127.0.0.1:5000:5000"    # 仅绑定本机，Nginx 反向代理访问
    volumes:
      - /mnt/registry/data:/var/lib/registry
      - /mnt/registry/config.yml:/etc/docker/registry/config.yml:ro

  
networks:
  default:

启动镜像

1	docker-compose up -d

配置nginx的server块

上面我示例的是dockerhub.playdemo.app，那么下面使用hub.playdemo.app示例

server {
listen 80;
server_name  hub.playdemo.app;
index index.html index.htm;
        gzip on;
        gzip_buffers 32 4K;
        gzip_comp_level 6;
        gzip_min_length 4000;
        gzip_types text/css text/xml application/x-javascript application/json text/javascript application/javascript;
        keepalive_timeout 30;
        ssl_session_timeout 5m;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384;

client_max_body_size 0;             # 取消大小限制:contentReference[oaicite:8]{index=8}
chunked_transfer_encoding on;       # 支持分块传输:contentReference[oaicite:9]{index=9}

location / {
proxy_pass http://127.0.0.1:5000;
proxy_set_header Host $http_host;       # Docker 客户端要求的 Host 头:contentReference[oaicite:10]{index=10}
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_read_timeout 900;
}
}

重启nginx

1	nginx -s reload

最后配置域名解析

进行测试

叔叔别拉了我害怕

2025-04-25T08:41:00.000Z

公鸡泻药澡堂半年假

2025-04-25T05:41:00.000Z

漫画-程序员笑话

2025-04-24T05:41:00.000Z

图床文件迁移

2025-04-01T03:34:00.000Z

Cloudflare R2 调用次数飙升

最近为了增强博客浏览体验，最终上了cdn，做了国内外分流。国内使用的是腾讯云EdgeOne，有一说一挺烂的，居然不支持自动部署证书，还得手动申请一个再关联上。。。对比Cloudflare的小黄云体验极差。

回到正题，众所周知，cloudflare R2按调用次数算，看了下数据，几天已经5w多次调用了，骇的我感觉考虑其他方案。

大盘鸡

原先我的图床搭建在家里得nas上，因为刷pt上了运营商黑名单，上传带宽只有50M，也就是上传速度就剩6.25了。所以也就将图片迁移到了Cloudflare R2上。因为上述原因加上一些其他考虑，最终还是决定弄个大盘鸡吧。

选择

正好cnfaster做活动，花了420多买了一个如下配置的香港VPS：

价格还是挺便宜的，就是不知道会不会跑路。流量8T，1000G硬盘放国内云厂商我都不敢想，这还是香港vps，可以打科学上网。

有需要的可以自己去看看

https://cnfaster.com/recommend/v5g7bb2wrgaV

迁移脚本

回到正题，Cloudflare R2有接近3个G的文件，上万张图片，不可能手动去做，所以就写了一个脚本去实现。有需要的github自取

https://github.com/chenqi92/CloneS3toS3

简单使用方式(其他相关配置可见md)：

拷贝文件并生成新的config.ini

然后执行命令即可

1	python main.py --config config.ini

实现效果

如何让deepseek R1模型摆脱束缚，回答一些敏感问题

2025-02-08T08:19:41.000Z

deepseek R1的本地化部署可以看我前篇内容，这篇跳过了

效果对比

这是没有问到没有训练过内容的效果

这是训练过内容，但是因为某种原因不能公开的效果

我就不把深度思考内容点开了，因为ai都知道不能说，我也不敢说

这是越狱版的效果

如何下载部署

部署方式和非越狱版一致，只是命令稍有不同。
模型所在地址:
https://ollama.com/huihui_ai
总共有7b、8b、14b、32b、70b五种（单指deepseek），这次我用的是4070Ti的台式机部署的，12g显存，所以下载了14b的版本。上篇文章用的是mac mini 16g内存所以用的是8b版本。

1	ollama run huihui_ai/deepseek-r1-abliterated:14b

当然如果你有4块4090，或者mac高内存的话，可以尝试用70b版本。比如小黑96g的mac M2 max试了一下70b版本，效果要明显好于32b，但是每秒只有几tokens。

本地化部署并使用开源语言大模型DeepSeek-R1

2025-02-05T02:41:00.000Z

DeepSeek-R1 是一款强大的自然语言处理模型，适用于多种任务，如文本生成、问答系统、对话生成等。

设备

我是用的mac mini 2023款的，M2芯片，16g内存。苹果的芯片比较特别，是统一内存架构，CPU、GPU和神经引擎都共享同一内存池，所以用来部署ai模型还是比较方便的。

Ollama

Ollama 是一个开源平台和工具，使用非常非常简单。Ollama旨在让用户更方便地在本地部署和运行大型语言模型（如GPT等）并进行推理。其目的是通过简化部署流程，让开发者和研究人员能够更容易地将AI模型（尤其是大型语言模型）集成到自己的应用中，而不必依赖于云服务提供商。

下面以Mac平台为例，windows和linux差不多。

下载

https://ollama.com/download?utm_source=lobehub&utm_medium=docs&utm_campaign=download-macos

配置 Ollama 允许跨域访问

由于 Ollama 的默认参数配置，启动时设置了仅本地访问，所以跨域访问以及端口监听需要进行额外的环境变量设置 OLLAMA_ORIGINS。使用 launchctl 设置环境变量：

1	launchctl setenv OLLAMA_ORIGINS "*"

完成设置后，需要重启 Ollama 应用程序。

下载模型

下载模型也很简单，再ollama启动后，执行以下命令即可：

1	ollama pull 模型名称

实际使用

1.直接控制台里面对话

2.自己写代码

比如：

import requests
import json

# 配置参数
OLLAMA_API_URL = "http://localhost:11434/api/generate"
MODEL_NAME = "deepseek-r1:7b"  # 需替换为Ollama中实际模型名称

def generate_response(prompt, stream=False):
    """
    调用Ollama API生成对话响应
    :param prompt: 用户输入的提示文本
    :param stream: 是否使用流式响应
    :return: 生成的文本或流式响应生成器
    """
    payload = {
        "model": MODEL_NAME,
        "prompt": prompt,
        "stream": stream,
        "options": {
            "temperature": 0.7,     # 控制随机性 (0.0-1.0)
            "max_tokens": 512,      # 最大生成token数
            "top_p": 0.9            # 控制生成多样性
        }
    }

    try:
        response = requests.post(
            OLLAMA_API_URL,
            json=payload,
            stream=stream,
            headers={"Content-Type": "application/json"},
            timeout=60
        )
        response.raise_for_status()

        if stream:
            # 处理流式响应
            for chunk in response.iter_lines():
                if chunk:
                    decoded_chunk = json.loads(chunk.decode("utf-8"))
                    yield decoded_chunk.get("response", "")
        else:
            # 处理非流式响应
            full_response = response.json()
            return full_response.get("response", "No response generated")

    except requests.exceptions.RequestException as e:
        print(f"API请求失败: {str(e)}")
        return None
    except json.JSONDecodeError:
        print("响应解析失败")
        return None

# 示例使用
if __name__ == "__main__":
    # 非流式对话示例
    user_input = "请用Python写一个快速排序算法"
    print(f"[用户]: {user_input}")
    response = generate_response(user_input)
    print(f"[AI]: {response}")

    # 流式对话示例
    print("\n流式对话演示:")
    user_input_stream = "解释量子计算的基本原理"
    print(f"[用户]: {user_input_stream}")
    for chunk in generate_response(user_input_stream, stream=True):
        print(chunk, end="", flush=True)
    print()

3.chrome插件

Page Assist插件，左上角选择模型，齿轮可以设置语言和模型相关参数。

4.lobe-chat

这个软件是一个各平台ai的集成工具，我部署的是一个服务器版，并配置了登录校验和知识库。这个工具可以随时切换各种模型使用，还是挺方便的。建议设置的时候勾选客户端模式，毕竟不少模型还是需要魔法的。

注意这软件有bug，连通性检查虽然不通过，但是实际模型是可以正常使用的。

家中网络建设与服务配置经验谈

2025-01-24T04:23:00.000Z

网络拓扑

  graph TB    Modem[光猫]    StudyRouter[书房主路由]    LivingRouter[客厅子路由]    Switch[2.5G交换机]    NAS[群晖923+]    IndustrialPC[N100软路由]    MiniPC1[迷你主机1]    MiniPC2[迷你主机2]    TV[TV]    PC[4070Ti主机]    SwitchConsole[智能设备网关]    AppleTV[Apple TV]    DesktopPC[4060主机]    Modem -->|网线| StudyRouter    StudyRouter -->|网线| LivingRouter    StudyRouter -->|光纤| Switch    StudyRouter -->|网线| PC    Switch -->|LAN| NAS    Switch -->|LAN| IndustrialPC    Switch -->|LAN| MiniPC1    Switch -->|LAN| MiniPC2    LivingRouter -->|LAN| TV    LivingRouter -->|LAN| SwitchConsole    LivingRouter -->|LAN| AppleTV    LivingRouter -->|LAN| DesktopPC    LivingRouter -.->|有线Mesh| StudyRouter

网线布控和宽带

网线布控

考虑到网线过多不美观，所以装修只从弱电箱引了两根弱电箱管道，分别到书房和客厅。
弱电箱位于客厅，只放置了光猫，入户光纤进入光猫。
光猫只使用了一个lan口，这个lan口接的网线通入书房主路由的wan口。
书房主路由的lan口使用网线通过弱电管道返回弱电箱中，再经过弱电管道直接到达客厅电视机下方的子路由，用于组有线mesh。

一般家庭装修其实采取的措施是光猫两个lan口分别到书房和客厅，或者是在弱电箱中加交换机。我采取的措施有点区别，是书房到客厅直接一根线不断，省了个路由器。

宽带

办理的电信千兆，因为不是2.5G套餐，所以没有给2.5G光猫，也就导致实际下载速度肯定是达不到千兆宽带的125 MB/s的。
找客服要了公网IPv4，客服没有多一句废话，只让你过十分钟重启即可。
最开始上传带宽具体多少没留意，因为刷PT太过嚣张，不到一周就刷了好几T，上了运营商黑名单，上传限制为50Mbps也就是6.25MB/s。PS：再给我一次机会绝对刷PT时先限速😩。

设备

机柜

找了很久找到了这么一个小的，主要是为了放在书房的桌子下面，加上滑动底座举例桌子底部有个5公分左右，在我看来无论位置还是大小挺完美的。自带了一个温控风扇，这玩意得吐槽一下，通电后没注意温控的传感器跟机柜侧壁金属直接接触，砰的一声直接爆掉，空开跳掉，只能将传感器剪掉后线直接接上，这个小风扇要么一直开或者一直关了。

机柜底座

找了一个洗衣机的底座来用，尺寸还挺合适。为什么要底座呢？因为上面这个机柜本身设置为挂着的，所以线路的开孔是在下方😂只能加个底座。

主路由

抱着一次折腾够，后续少折腾的想法，主路由直接上了万兆，4个网线口+1个光纤口。此外，加了一个usb用来跑docker，小米自带的docker管理工具事simpler Docker，用过的自有体会😞

Mesh子路由

我这配置买高了，实际上随便一个同品牌的就够了。

交换机

买这个交换机主要还是为了减少路由器到设备间的网线，原本需要4跟傻大粗的网线从桌子上方通到下方，很丑，所以干脆上了光纤。需要注意的是光纤口其实有多种，要注意设备间的适配。

光纤头子

光纤自带的接口实际上是无法插入家用设备的，需要搭配这个头子来使用，也就是光纤的接口插入这个头子，头子再插入路由器或者交换机，话说这玩意还挺贵的😂可以上咸鱼找找，应该有不少机房淘汰的但能用的。

NAS

用的群晖923+，群晖胜在系统稳定，生态齐全，如果你有国外的apple id你会发现他家其实还有很多的软件能够下载。群晖硬件很拉跨，一直被吐槽买软件送硬件。这台机器买之前一直用的ds218+，结果咸鱼上居然还能以60%价格出手，不算很亏。硬盘我是上了4块4T酷狼，因为怕吵就没上氦气盘。考虑到影视的存储，单独买了一块16T的用外置硬盘盒挂在了群晖上。

软路由

N100的机器，主要用来做软路由，刷的istoreOS。软路由嘛懂得都懂，主要是用来富强和跳广告的。除此之外，这台机器安装PT相关的各种套件，如nastool，qb等，在阿里云没限制挂载前，也弄过小雅alist。自从阿里云来那么一出，再也不相信任何网盘了。这里多说一句，畅网是真扣，硅脂舍不得用。买回来不加硅脂前CPU常态80、90度，加了之后稳定40度以下。

mac mini

在咸鱼上花了几块钱找学生弄了个教育版优惠，少不少钱。平时主要用来开发，附带装了Emby，实在是Emby装N100里实在是难为它了。题外话，2024的mac mini加上国补性价比吊打各个小主机。

迷你主机

考虑到机柜它就那么大，能放的实在有限，只能放迷你主机了。陆续入手了2台，主要用来跑各种第三方服务，以及自己开发的一些业务服务，通过公网代理出去使用，云服务器实在用不起。分别为机械师和雷神，最近看了一款MS-01还不错，有点后悔机械师入手早了。

服务篇

这里就集中起来大概列举一些自己能记得的

NasTool 管理PT站点，自动订阅影视内容
Emby 影视内容统一管理，刮削生成海报墙
qBittorrent PT影视下载
WireGuard 用于公网服务器和家中主机组网，将服务从公网服务器代理出去
minio 主要用来做图床用
qinglong 定时脚本管理平台，薅羊毛必备
reader 阅读服务器版
timescaledb 时序数据库
music_tag 音乐刮削
vaultwarden 多平台密码管理
gitea 私有代码仓库
lobe-chat 各平台ai聚合
acme.sh 自动的免费续签ssl证书
kkfileview 文件预览服务
mysql 关系型数据库
redis 内存数据库
rabbitmq 消息队列
dailyhot-api 每日热点

github无法通过ssh推送或者拉取的一种解决办法

2025-01-03T06:04:00.000Z

前景提要

今天突然发现github无法通过ssh推送或者拉取了，研究了以下找到了一个解决办法。
提交时的错误如图，ssh密钥已经配置进GitHub了，仓库的权限也没有任何问题，但是就是无法进行ssh的操作。

解决办法

在ssh密钥的储存目录新建一个config文件，内容如下

Host github.com
Hostname ssh.github.com
Port 443
User git

然后重新进行git的操作，就可以正常进行了。

群晖nas安装timescaledb时序数据库

2024-12-23T02:15:00.000Z

前言

最近有时序库的需求，我常用的是influxdb和timescaledb，influxdb是专门的时序库，timescaledb是在postgresql上的时序库，因为写法更接近于mysql，后端服务做动态库切换挺方便的，所以我选择了timescaledb。

安装

准备

因为众所周知的原因，docker源被墙了，所以群晖里面如果想用，必须要用到镜像源。我是自己利用cloudflare自己搭的，你们有需要也可以使用。
我的镜像源地址为: https://dockerhub.allbs.xyz

群晖中的配置方法为:

修改后别忘记点击使用按钮，使其生效。

搜索安装

因为我的群晖直接在搜索框中筛选出结果，所以我只能使用命令行安装了，如果可视化面板操作没问题的可以跳过我这一步。

1	docker pull timescale/timescaledb:latest-pg17

下载完成后刷新列表即可看到映像已经加载出来了

环境配置

点击映像->允许->勾选自动重新启动->下一步

配置映射端口->配置映射的文件夹名称->配置数据库访问账号密码

端口我配置的6543是因为我的本地5432被占用了，前面的端口可以随意配置，是你最后在其他电脑中访问所使用的端口。
文件夹映射，第一列是你自己的物理磁盘中的文件夹路径，第二列是下面环境中PGDATA的值。

配置账号密码

POSTGRES_USER是你访问的账户名
POSTGRES_PASSWORD就是这个账户访问的密码

点击下一步然后再点击完成即可。先不着急启动，配置远程访问。

配置远程访问

从物理磁盘中下载`postgresql.conf`和`pg_hba.conf`文件

修改其中的配置：

postgresql.conf

确保属性值为*，我记得以前再centeros上安装时需要手动修改这个值的，不知道时版本还是系统原因，这个默认就是*。

pg_hba.conf

这个是肯定需要改的
注释红框上面一行或者添加红框内容

1	host all all 0.0.0.0/0 md5

修改两个文件之后替换物理磁盘中的两个原文件，然后启动。

使用客户端工具尝试访问

datagrip、navicat等挺多数据库连接工具都可以。

使用家庭网络将内网服务映射到公网访问

2024-12-18T03:02:00.000Z

前言

众所周知，云服务器稍微高一点的配置价格有多贵，但是它优点是有固定的公网ip。而家庭网络要么是没有公网ip，要么有公网ip开放web服务会被运营商封掉(如果域名不备案还做了ddns、并且还有对外的web服务)。那么有没有办法将家庭内网服务映射到公网访问呢？答案是有的，内网穿透技术就是为了解决这个问题而生的。我下面就要讲讲如何将一个家庭内网的web服务映射到公网，而且还不带端口访问。

当前设备

一台云服务器(ubuntu)，我这是腾讯云的新加坡的云服务器，这样就可以域名解析不用备案了。
一个注册在赛博菩萨cloudflare上的域名，这样可以很方便的用他们的ssl证书和ddos防护。
一台内网服务器(ubuntu)，是一台迷你机。

大致流程

云服务器安装WireGuard服务端。
内网主机部署了一个后台服务和一个web服务，web服务使用nginx代理。
内网主机安装WireGuard客户端。
云服务器和内网主机建立WireGuard连接。
云服务器配置nginx代理，将内网主机的web服务映射到公网。
cloudflare解析域名到云服务器的公网ip。

具体流程说明

云服务器安装WireGuard服务端

可以借助脚本一键安装仓库地址为

安装脚本

# 安装
wget -O wireguard.sh https://get.vpnsetup.net/wg

# 执行
sudo bash wireguard.sh

具体交互步骤我就不说了，默认的就行
新建客户端,就是脚本的指令1 如下图，客户端名称随意，自己能分辨即可，我这里是创建了两个，一个给工作的windows，一个就是给内网的迷你主机。

生成的配置文件在/root目录下，名称为你起的名称.conf

windows有客户端直接导入即可

ubuntu中放在/etc/wireguard目录下，改名为wg0.conf，然后通过命令

1	wg-quick up wg0

启动即可。

使用命令设置开机启动

1	systemctl enable wg-quick@wg0

至此两台机器组网完成，可以使用wg指令查看

云服务器

内网迷你机

注意

云服务器需要将默认的51820 UDP端口开放，如果你没改的话，家庭网络不需要开发端口。

迷你机的web服务

我使用的是nginx代理的，端口为8899，所以下一步就是需要在云服务器上将流量转发到这台迷你机的8899端口上。

转发流量

云服务器上我依然使用的nginx代理的，当然也有其他办法可以实现，有兴趣的可以自己找找。

nginx配置如下:

下面的10.7.0.3就是内网迷你机组网的地址，并不是你路由器给他分配的地址！因为我有webocket的需求，所以多加了一个ws的配置，没有需求的可以去掉。

server {
listen 80 default_server;
server_name _;

location /ws {
proxy_pass http://10.7.0.3:8899/ws;  # 转发到内网主机的 /ws 路径
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;

# 设置超时时间
proxy_read_timeout 600s;
proxy_send_timeout 600s;
proxy_connect_timeout 600s;
}

location / {
proxy_pass http://10.7.0.3:8899;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}

配置域名访问

实际上述内容配置完之后是可以通过你云服务器:80来进行访问的，你后续只需要在cloudflare上配置域名解析@到你的这个云服务器的ip地址即可。

使用java封装了一个脱敏组件

2024-11-12T08:25:00.000Z

功能说明

因为最近有脱敏的需求，所以就趁着这个机会自己实现了一个。肯定还有不少开源库有这种功能，但是考虑到不一定满足自己的需要，所以就自己造了一个轮子自己用。主要功能包括

接口返回内容的脱敏，包含json序列化方式和aop的两种实现。
json序列化方式只能用于接口数据返回，在程序内部和数据库并不脱敏。
aop的方式，在程序内部和接口数据返回时可以脱敏，但是数据库不脱敏，且速度是慢于序列化方式的。
根据自己的需求来实现脱敏规则，比如有些人的手机号脱敏是中间四位，有些人又只保留初始和末尾一位。
自定义脱敏字符，默认为*。
请求体数据自动过滤，比如你传向前端的数据是包含脱敏字符的，正常的做法是前端判断时候包含脱敏字符，如果包含则该字段不往后端传输。我这边实现的是，如果请求体传过来的数据内容跟改字段的脱敏规则一致则不接收该字段内容，不，准确的说是在接收该字段内容之前转为null。

使用示例

总共有四种使用场景：

1.作用与方法上的aop注解

@Desensitizes({@Desensitize(field = "username", exclude = true), @Desensitize(field = "phoneNumber", type = MobilePhoneDesensitizer.class), @Desensitize(field = "email", type = EmailDesensitizer.class, maskChar = "#")})  
@GetMapping("/testMethodAnno")  
public TestNoAnnoVO testMethodAnno() {  
    TestNoAnnoVO test = new TestNoAnnoVO();  
    test.setUsername("JohnDoe");  
    test.setPhoneNumber("13812345678");  
    test.setEmail("john.doe@example.com");  
    return test;  
}

@Data  
public class TestNoAnnoVO {  
  
    private String username;  
  
    private String phoneNumber;  
  
    private String email;  
}

输出内容为:

2.作用于实体字段的aop注解

@GetMapping("/testFieldAnno")  
public TestVO testFieldAnno() {  
    TestVO test = new TestVO();  
    test.setUsername("JohnDoe");  
    test.setPhoneNumber("13812345678");  
    test.setEmail("john.doe@example.com");  
    test.setIdCard("123456199001011234");  
    return test;  
}

public class TestVO {  
  
    @Desensitize(exclude = true)  
    private String username;  
  
    @Desensitize(type = MobilePhoneDesensitizer.class)  
    private String phoneNumber;  
  
    @Desensitize(type = EmailDesensitizer.class, maskChar = "#")  
    private String email;  
  
    @Desensitize(type = IDCardDesensitizer.class, maskChar = "%")  
    private String idCard;  
}

输出内容为：

3.序列化注解

@GetMapping("/testJsonAnno")  
public TestJsonVO testJsonAnno() {  
    TestJsonVO test = new TestJsonVO();  
    test.setUsername("JohnDoe");  
    test.setPhoneNumber("13812345678");  
    test.setEmail("j@example.com");  
    test.setIdCard("123456199001011234");  
    return test;  
}

@Data  
public class TestJsonVO {  
  
    @JsonDesensitize(exclude = true)  
    private String username;  
  
    @JsonDesensitize(type = MobilePhoneDesensitizer.class)  
    private String phoneNumber;  
  
    @JsonDesensitize(type = EmailDesensitizer.class, maskChar = "#")  
    private String email;  
  
    @JsonDesensitize(type = IDCardDesensitizer.class)  
    private String idCard;  
}

这个有些区别，如果设置了exclude为true，则直接将返回的该字段隐去。输出内容为:

4.最后就是基于`@JsonDesensitize`额外加了一个属性`ignoreDesensitized`，用于判断是否在接收数据时排除脱敏内容。

@PostMapping("testPut")  
public void testPut(@RequestBody TestDTO testDTO) {  
    log.info("接收到的数据内容为{}", testDTO.toString());  
}

@Data  
public class TestDTO {  
  
    @JsonDesensitize(exclude = true, ignoreDesensitized = true)  
    private String username;  
  
    @JsonDesensitize(type = MobilePhoneDesensitizer.class, ignoreDesensitized = true)  
    private String phoneNumber;  
  
    @JsonDesensitize(type = EmailDesensitizer.class, maskChar = "#", ignoreDesensitized = true)  
    private String email;  
  
    @JsonDesensitize(type = IDCardDesensitizer.class, ignoreDesensitized = true)  
    private String idCard;  
}

使用效果为：

这个是严格按照输出时的脱敏匹配的，比如输出时手机号脱敏内容为138****1234,那么136****4321则不会接收，正常没有*的手机号或者不符合该规则的比如13****51234这种也会被正常接收。当然这个规则是可以在项目中自定义的。

使用说明

项目地址

https://github.com/chenqi92/alltobs-desensitization-all
里面包含待引入的jar和demo，因为刚写完，简单测试了一下不排除有其他bug，有需要可以自己fork一下自己改。后续我会在项目中实际使用，如果发现有bug会不断更新，当然也欢迎提issuses。

引入jar

<dependency>  
    <groupId>com.alltobsgroupId>  
    <artifactId>alltobs-desensitizationartifactId>  
    <version>1.0.0version>  
dependency>

工具已经上传到了maven的中央仓库，国内的用户可能存在下载困难等问题，需要科学一下。使用国内的阿里等平台代理，以我以往经验同步过去起码要半个月把。

启用功能

启动类添加注解@EnableAllbsDesensitization

根据自己使用场景的需要、以及上述示例来选择性的添加注解

@Desensitize
@Desensitizes
@JsonDesensitize

自定义在项目中实现一个自己需要的脱敏方式

如果你不想用默认的脱敏方式，实际上我也没写几个，后续应该会接着加。
那么就在你的项目工程中自定义集成BaseDesensitizer类然后自己实现desensitize和getDesensitizedRegex方法即可。
这两个方法一个是用于脱敏规则，一个是用于接收数据时判断是否符合规则。
具体实现以身份证号为例:

package com.alltobs.alltobsdesensitizationdemo.desensitizer;  
  
import com.alltobs.desensitization.desensitizer.BaseDesensitizer;  
  
import java.util.regex.Pattern;  
  
/**  
 * 类 IDCardDesensitizer  
 * * @author ChenQi  
 * @date 2024/11/11  
 */public class IDCardDesensitizer extends BaseDesensitizer {  
  
    @Override  
    public String desensitize(String value, String maskChar) {  
        if (value != null && (value.length() == 15 || value.length() == 18)) {  
            // 脱敏中间部分  
            int prefixLength = 6;  
            int suffixLength = 4;  
            int maskLength = value.length() - prefixLength - suffixLength;  
  
            String prefix = value.substring(0, prefixLength);  
            String suffix = value.substring(value.length() - suffixLength);  
            String maskedSection = maskChar.repeat(maskLength);  
            return prefix + maskedSection + suffix;  
        }  
        return value;  
    }  
  
    @Override  
    public String getDesensitizedRegex(String maskChar) {  
        String escapedMaskChar = Pattern.quote(maskChar);  
        // 身份证号可能是 15 位或 18 位，这里统一处理  
        String maskPattern = escapedMaskChar + "+";  
        return "^\\d{6}" + maskPattern + "\\d{4}$";  
    }  
}

开源可自部署的文生图ai大模型，效果比肩aimidjourney

2024-08-18T07:31:00.000Z

前言

本来想先搭载一个平台给大伙试试，但是考虑到很吃显卡需要GPU相关的服务器。买云服务器太贵，用自己家里面电脑跑的话又涉嫌对外提供Web服务，会被运营商封号，加上的模型能够生成你们懂的的那种图，这下好了，buff叠满，没一丝的可能搭载给你们体验。只能把教程发出来教你们自己去尝试了。前排提示，末尾有生成效果和我打包好的可以直接使用的包，包内内置三种低端点的模型，缺少最高端flex-dev的模型，需要的话vb自己去找资源。

模型区分

Flux Pro: 顶级模型只能通过API调用
Flux Dev: 开源但是不能商用，质量效果和pro类似
Flux Schnell: 高度提炼版，速度快，能商用。

开始搭建

首先考虑到很多用户并不具备api调用的能力，所以先要准备一个ui交互的界面来方便操作。ComfyUI是一个具有高度可配置、支持多种模型、跨平台支持等特点的节点式界面。

ComfyUI的下载使用

开源地址: https://github.com/comfyanonymous/ComfyUI

下载加压后备用

下载中文语言包

考虑到很多人不一定安装了git，可以直接下载zip包解压到ComfyUI/custom_nodes目录下。

地址:https://github.com/AIGODLIKE/AIGODLIKE-ComfyUI-Translation

下载CLIP模型

CLIP模型是由OpenAI开发的一种多模态模型，能够理解并关联自然语言和图像。CLIP的核心思想是在训练过程中通过对比学习的方式，将图像和文本映射到一个共享的向量空间中，从而实现文本和图像之间的相互理解和转换。
下载两个文件放到ComfyUI/models/clip/目录下

显存超过32G，下载t5xxl_fp16.safetensors,地址:https://huggingface.co/comfyanonymous/flux_text_encoders/blob/main/t5xxl_fp16.safetensors
没超过，下载t5xxl_fp8_e4m3fn.safetensors，地址:https://huggingface.co/comfyanonymous/flux_text_encoders/blob/main/t5xxl_fp8_e4m3fn.safetensors
这个是必须下的，地址: https://huggingface.co/comfyanonymous/flux_text_encoders/blob/main/clip_l.safetensors

下载 VAE 生成模型

下载解压到ComfyUI/models/vae/目录下
下载地址:https://huggingface.co/black-forest-labs/FLUX.1-schnell/blob/main/ae.safetensors

下载最核心的大模型

根据电脑的显卡配置下载不同的模型后解压到ComfyUI/models/unet/目录下。

显存24G，下载FLUX.1-dev，地址https://huggingface.co/black-forest-labs/FLUX.1-dev/tree/main
显存12G，下载flux-fp8，地址https://huggingface.co/Kijai/flux-fp8/blob/main/flux1-dev-fp8.safetensors
显存还要低，下载FLUX.1-schnell，地址https://huggingface.co/black-forest-labs/FLUX.1-schnell/blob/main/flux1-schnell.safetensors
显卡实在垃圾，下载flux-fp8，地址https://huggingface.co/Kijai/flux-fp8/blob/main/flux1-schnell-fp8.safetensors

运行

有n卡的跑这个bat即可

设置中文

开始配置

打开网站:https://comfyanonymous.github.io/ComfyUI_examples/flux/

将图片拖到刚才运行的网页中自动加载参数。效果如下:

下面就可以根据文字来生成图片了

毕竟老外的模型，还是的英文提示词，如果最好将想好的中文先翻译为英文来使用。

演示一：村里发魅魔了

演示二：

演示三：

不可描述的图片我试了一下确实可以生成，但是这里就不给你们做演示了。

直接放好模型配置好中文的压缩包

通过百度网盘分享的文件：ComfyUI_windows_portable.rar
链接：https://pan.baidu.com/s/1YNDYTSlUw8S9t16gx2M_yA
提取码：rywi

解压后并运行bat后把同目录的图片拖入网页中

封装了支持S3协议的文件服务器(如minio、阿里云OSS、腾讯云)的相关操作，支持分片上传、断点续传、不经过后端服务上传

2024-08-13T01:25:00.000Z

包含的主要功能和示例

创建bucket
删除bucket
文件上传
拷贝文件
删除文件
文件下载
设置文件标签
上传文件指定时间自动删除
上传文件并加密
分片上传
断点续传
生成预签名url，直接前端上传不经过后端

源码地址

使用demo地址

demo地址

前置测试环境

首先使用docker-compose安装了最新的minio用于测试

version: '3'

  minio:
    image: minio/minio
    container_name: minio
    restart: always
    ports:
      - "9000:9000" # api端口
      - "9001:9001" # 控制台端口
    environment:
      MINIO_ROOT_USER: "miniouser"      # 设置你的访问账户(用于控制台访问)
      MINIO_ROOT_PASSWORD: "123456789"  # 设置你的访问密钥(用于控制台访问)
    volumes:
      - /mnt/minio/files:/data                   # 将容器中的 /data 文件夹挂载到主机上的指定文件夹 我使用的是/mnt/minio/files
    command: server /data --console-address ":9001"

项目引入依赖

这里说明一下cn.allbs这个group用于jdk1.8，com.alltobs用于jdk17+，但是cn.allbs中有一点点jdk17，遇到的话降级点版本。

<dependency>
  <groupId>com.alltobsgroupId>
  <artifactId>alltobs-ossartifactId>
  <version>1.0.0version>
dependency>

项目配置

配置文件

oss:
  endpoint: http://xxx.xxx.xxx.xxx:9000
  # 所在地区
  region: cn-north-1
  # minio账号或者
  access-key: adadmin
  # 密码
  secret-key: 123456778
  # 设置一个默认的文件桶，比如不同项目使用同一个文件库，以项目为文件桶分隔
  bucket-name: test
  # 设置会过期的子文件桶
  expiring-buckets:
    temp-bucket-1: 30  # 生命周期30天
    temp-bucket-2: 60  # 生命周期60天

endpoint就是安装minio或者腾讯云、阿里云之类的对象储存地址
region所在地区
access-key可以直接使用控制台账号，但是建议在控制台中生成账号和密钥
secret-key可以直接使用控制台密钥，但是建议在控制台中生成账号和密钥
bucket-name 设置一个默认的文件桶，比如不同项目使用同一个文件库，以项目为文件桶分隔
expiring-buckets 里面设置的是包含生命周期的文件夹，创建位置位于bucket-name下，比如bucket-name叫test,那么会在test目录下创建一个生命周期为30天的文件夹temp-bucket-1，生命周期为60天的文件夹temp-bucket-2

启动类注解`@EnableAllbsOss`

使用引入

1 2	@Resource private OssTemplate ossTemplate;

使用演示

以下所有方法都遵循一个原则，当bucket-name不为空时，所有操作都在这个bucket下进行。

就会自动创建文件桶如下，一个位于test目录下且十天后会自动删除的expire-bucket-1

创建bucket

@PostMapping("/createBucket")  
public ResponseEntity createBucket(@RequestParam String bucketName) {  
    ossTemplate.createBucket(bucketName);  
    return ResponseEntity.ok("Bucket created: " + bucketName);  
}

查询所有bucket

@GetMapping("/getAllBuckets")  
public R> getAllBuckets() {  
    return R.ok(ossTemplate.getAllBuckets());  
}

删除指定bucket

@DeleteMapping("/removeBucket")  
public R removeBucket(@RequestParam String bucketName) {  
    ossTemplate.removeBucket(bucketName);  
    return R.ok("Bucket removed: " + bucketName);  
}

上传文件

@PostMapping("/putObject")  
public R putObject(@RequestParam String bucketName, @RequestParam MultipartFile file) {  
    String fileName = file.getOriginalFilename();  
    try {  
        String uuid = UUID.randomUUID() + "." + FileUtil.getFileType(fileName);  
        ossTemplate.putObject(bucketName, uuid, file.getInputStream());  
        return R.ok("File uploaded: " + uuid);  
    } catch (IOException e) {  
        return R.fail("Failed to upload file: " + fileName);  
    }  
}

查询指定目录下指定前缀的文件

@GetMapping("/getAllObjectsByPrefix")  
public R> getAllObjectsByPrefix(@RequestParam String bucketName, @RequestParam String prefix) {   
    return R.ok(ossTemplate.getAllObjectsByPrefix(bucketName, prefix).stream().map(S3Object::key).collect(Collectors.toSet()));  
}

查看文件(字节数组)

@GetMapping("/getObject")  
public R<byte[]> getObject(@RequestParam String bucketName, @RequestParam String objectName) {  
    try (var s3Object = ossTemplate.getObject(bucketName, objectName)) {  
        return R.ok(s3Object.readAllBytes());  
    } catch (IOException e) {  
        return R.fail(e.getLocalizedMessage());  
    }  
}

下载文件

@GetMapping("/download")  
public void download(@RequestParam String bucketName, @RequestParam String objectName, HttpServletResponse response) {  
    try (ResponseInputStream inputStream = ossTemplate.getObject(bucketName, objectName);  
         OutputStream outputStream = response.getOutputStream()) {  
  
        // 获取文件的Content-Type  
        String contentType = inputStream.response().contentType();  
        response.setContentType(contentType);  
  
        // 设置响应头：Content-Disposition，用于浏览器下载文件时的文件名  
        response.setHeader("Content-Disposition", "attachment; filename=\"" + objectName + "\"");  
  
        // 直接将输入流中的数据传输到输出流  
        inputStream.transferTo(outputStream);  
  
        // 刷新输出流，确保所有数据已写出  
        outputStream.flush();  
  
    } catch (IOException e) {  
        // 如果出错，设置响应状态为404  
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);  
    }  
}

查看文件链接带过期时间

@GetMapping("/getObjectURL")  
public R getObjectURL(@RequestParam String bucketName, @RequestParam String objectName, @RequestParam int minutes) {  
    return R.ok(ossTemplate.getObjectURL(bucketName, objectName, minutes));  
}

删除文件

@DeleteMapping("/removeObject")  
public R removeObject(@RequestParam String bucketName, @RequestParam String objectName) {  
    ossTemplate.removeObject(bucketName, objectName);  
    return R.ok("Object removed: " + objectName);  
}

文件复制

@PostMapping("/copyObject")  
public R copyObject(@RequestParam String sourceBucketName, @RequestParam String sourceKey,  
                            @RequestParam String destinationBucketName, @RequestParam String destinationKey) {  
    ossTemplate.copyObject(sourceBucketName, sourceKey, destinationBucketName, destinationKey);  
    return R.ok("Object copied from " + sourceKey + " to " + destinationKey);  
}

查询指定文件的访问权限

@GetMapping("/getObjectAcl")  
public R getObjectAcl(@RequestParam String bucketName, @RequestParam String objectName) {  
    return R.ok(ossTemplate.getObjectAcl(bucketName, objectName).toString());  
}

设置指定文件的访问权限

@PostMapping("/setObjectAcl")  
public R setObjectAcl(@RequestParam String bucketName, @RequestParam String objectName, @RequestParam String acl) {  
    ossTemplate.setObjectAcl(bucketName, objectName, acl);  
    return R.ok("ACL set for object: " + objectName);  
}

启用或者关闭指定bucket版本控制

@PostMapping("/setBucketVersioning")  
public R setBucketVersioning(@RequestParam String bucketName, @RequestParam boolean enable) {  
    ossTemplate.setBucketVersioning(bucketName, enable);  
    return R.ok("Versioning set to " + (enable ? "Enabled" : "Suspended") + " for bucket: " + bucketName);  
}

给指定文件打标签

@PostMapping("/setObjectTags")  
public R setObjectTags(@RequestParam String bucketName, @RequestParam String objectName, @RequestBody Map tags) {  
    ossTemplate.setObjectTags(bucketName, objectName, tags);  
    return R.ok("Tags set for object: " + objectName);  
}

获取指定文件的标签

@GetMapping("/getObjectTags")  
public R> getObjectTags(@RequestParam String bucketName, @RequestParam String objectName) {  
    return R.ok(ossTemplate.getObjectTags(bucketName, objectName));  
}

上传一个会定时删除的文件

@PostMapping("putObjectWithExpiration")  
public R putObjectWithExpiration(@RequestParam String bucketName, @RequestParam MultipartFile file, @RequestParam int days) {  
    String fileName = file.getOriginalFilename();  
    try {  
        String uuid = UUID.randomUUID() + "." + FileUtil.getFileType(fileName);  
        ossTemplate.putObjectWithExpiration(bucketName, uuid, file.getInputStream(), days);  
        return R.ok("File uploaded: " + uuid);  
    } catch (IOException e) {  
        return R.fail("Failed to upload file: " + fileName);  
    }  
}

上传加密文件

需要在服务端配置KMS，这里使用的是默认的AES256，其他可以调putObjectWithEncryption方法

@PostMapping("/uploadWithEncryption")  
public R uploadWithEncryption(@RequestParam String bucketName,  
                                      @RequestParam("file") MultipartFile file) {  
    String uuid = UUID.randomUUID() + "." + FileUtil.getFileType(file.getOriginalFilename());  
    try (InputStream inputStream = file.getInputStream()) {  
        PutObjectResponse response = ossTemplate.uploadWithEncryption(  
                bucketName,  
                uuid,                inputStream,                file.getSize(),  
                file.getContentType()  
        );  
        return R.ok("File uploaded with encryption: " + response.toString());  
    } catch (IOException e) {  
        return R.fail("File upload failed: " + e.getMessage());  
    }  
}

分片上传

@PostMapping("/uploadMultipart")  
public R uploadMultipart(@RequestParam String bucketName,  
                                 @RequestParam MultipartFile file) throws IOException, InterruptedException {  
    String objectName = file.getOriginalFilename();  
    // 初始化分片上传  
    String uploadId = ossTemplate.initiateMultipartUpload(bucketName, objectName);  
  
    // 将文件按部分大小（5MB）分块上传  
    long partSize = 5 * 1024 * 1024;  
    long fileSize = file.getSize();  
    int partCount = (int) Math.ceil((double) fileSize / partSize);  
  
    // 用于存储已上传的部分  
    List completedParts = Collections.synchronizedList(new ArrayList<>());  
  
    // 创建线程池  
    ExecutorService executor = Executors.newFixedThreadPool(Math.min(partCount, 10));  
  
    for (int i = 0; i < partCount; i++) {  
        final int partNumber = i + 1;  
        long startPos = i * partSize;  
        long size = Math.min(partSize, fileSize - startPos);  
  
        executor.submit(() -> {  
            try (InputStream inputStream = file.getInputStream()) {  
                inputStream.skip(startPos);  
                byte[] buffer = new byte[(int) size];  
                int bytesRead = inputStream.read(buffer, 0, (int) size);  
  
                if (bytesRead > 0) {  
                    CompletedPart part = ossTemplate.uploadPart(bucketName, objectName, uploadId, partNumber, buffer);  
                    completedParts.add(part);  
                }  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        });  
    }  
  
    executor.shutdown();  
    executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);  
  
    // 检查是否成功上传了所有部分  
    if (completedParts.size() == partCount) {  
        // 在完成上传之前，按 partNumber 升序排序  
        completedParts.sort(Comparator.comparing(CompletedPart::partNumber));  
  
        // 完成分片上传  
        ossTemplate.completeMultipartUpload(bucketName, objectName, uploadId, completedParts);  
        return R.ok("Upload completed successfully uploadId: " + uploadId);  
    } else {  
        // 如果有部分上传失败，取消上传  
        ossTemplate.abortMultipartUpload(bucketName, objectName, uploadId);  
        return R.fail("Upload failed, some parts are missing.");  
    }  
}

断点续传

uploadId是上一步分片上传获取到的，可以做个的记录，方便断点续传时使用。我这边测试方法是分片上传过程中直接终止了服务。

@PostMapping("/resumeMultipart")  
public R resumeMultipart(@RequestParam String bucketName,  
                                 @RequestParam MultipartFile file,  
                                 @RequestParam String uploadId) throws IOException, InterruptedException {  
    String objectName = file.getOriginalFilename();  
  
    // 将文件读入内存  
    byte[] fileBytes = file.getBytes();  
  
    // 获取已经上传的部分  
    List completedParts = ossTemplate.listParts(bucketName, objectName, uploadId);  
  
    // 继续上传未完成的部分  
    long partSize = 5 * 1024 * 1024;  
    long fileSize = fileBytes.length;  
    int partCount = (int) Math.ceil((double) fileSize / partSize);  
  
    ExecutorService executor = Executors.newFixedThreadPool(Math.min(partCount, 10));  
  
    for (int i = completedParts.size(); i < partCount; i++) {  
        final int partNumber = i + 1;  
        long startPos = i * partSize;  
        long size = Math.min(partSize, fileSize - startPos);  
  
        executor.submit(() -> {  
            try {  
                byte[] buffer = Arrays.copyOfRange(fileBytes, (int) startPos, (int) (startPos + size));  
                CompletedPart part = ossTemplate.uploadPart(bucketName, objectName, uploadId, partNumber, buffer);  
                synchronized (completedParts) {  
                    completedParts.add(part);  
                }  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        });  
    }  
  
    executor.shutdown();  
    executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);  
  
    // 按 partNumber 升序排序  
    completedParts.sort(Comparator.comparing(CompletedPart::partNumber));  
  
    // 完成分片上传  
    ossTemplate.completeMultipartUpload(bucketName, objectName, uploadId, completedParts);  
  
    return R.ok("Upload resumed and completed successfully");  
}

前端不通过后台服务器使用预签名的表单上传数据

使用这种方式可以让客户端能够直接与 S3 进行交互，减少了服务器的负担，并且可以利用 S3 的上传能力进行大文件的处理。

@GetMapping("/generatePreSignedUrl")  
public R generatePreSignedUrl(@RequestParam String bucketName,  
                                      @RequestParam String objectName,  
                                      @RequestParam int expiration) {  
    String preSignedUrl = ossTemplate.generatePreSignedUrlForPut(bucketName, objectName, expiration);  
    return R.ok(preSignedUrl);  
}

前面的demo

html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <meta name="viewport" content="width=device-width, initial-scale=1.0">  
    <title>文件上传title>  
    <style>        body {  
            font-family: Arial, sans-serif;  
            margin: 20px;  
        }  
  
        .upload-container {  
            max-width: 500px;  
            margin: 0 auto;  
            padding: 20px;  
            border: 2px solid #ccc;  
            border-radius: 10px;  
            text-align: center;  
        }  
  
        .file-input {  
            margin-bottom: 20px;  
        }  
  
        .progress-bar {  
            width: 100%;  
            background-color: #f3f3f3;  
            border-radius: 5px;  
            overflow: hidden;  
            margin-bottom: 10px;  
        }  
  
        .progress {  
            height: 20px;  
            background-color: #4caf50;  
            width: 0;  
        }  
    style>  
head>  
<body>  
<div class="upload-container">  
    <h2>上传文件到 S3h2>  
    <input type="file" id="fileInput" class="file-input"/>  
    <div class="progress-bar">  
        <div class="progress" id="progressBar">div>  
    div>  
    <button onclick="uploadFile()">上传文件button>  
    <p id="statusText">p>  
div>  
  
<script>  
    async function uploadFile() {  
        const fileInput = document.getElementById('fileInput');  
        const file = fileInput.files[0];  
  
        if (!file) {  
            alert('请选择一个文件进行上传');  
            return;  
        }  
  
        // 获取预签名 URL        const response = await fetch(`/oss/generatePreSignedUrl?bucketName=myBucket&objectName=${file.name}&expiration=15`);  
        const result = await response.json();  
  
        if (result.code !== 200) {  
            document.getElementById('statusText').innerText = '获取预签名URL失败';  
            return;  
        }  
  
        const presignedUrl = result.data;  // 从返回的 JSON 数据中提取预签名的 URL  
        const xhr = new XMLHttpRequest();  
        xhr.open('PUT', presignedUrl, true);  
        xhr.setRequestHeader('Content-Type', file.type);  
  
        // 更新进度条  
        xhr.upload.onprogress = function(event) {  
            if (event.lengthComputable) {  
                const percentComplete = (event.loaded / event.total) * 100;  
                document.getElementById('progressBar').style.width = percentComplete + '%';  
            }  
        };  
  
        // 处理上传完成后的事件  
        xhr.onload = function() {  
            if (xhr.status === 200) {  
                document.getElementById('statusText').innerText = '文件上传成功！';  
            } else {  
                document.getElementById('statusText').innerText = '文件上传失败，请重试。';  
            }  
        };  
  
        // 错误处理  
        xhr.onerror = function() {  
            document.getElementById('statusText').innerText = '文件上传过程中出现错误。';  
        };  
  
        xhr.send(file);  
    }  
script>  
body>  
html>

小程序由个人认证变更企业认证

2024-08-08T03:40:00.000Z

背景

因为个人认证功能限制太多，导致万能文件浏览还需要跳转浏览器才能查看，这让我感到非常不便。所以，我决定无论如何都要进行企业认证。起初我考虑注册个体工商户，但在了解流程和每年的报税要求后，觉得有些麻烦。最终，我决定挂靠在表哥的公司名下进行认证。

大致流程

设置->主体信息->小程序主体变更

变更主要内容有:

原个人主体的身份证正反面合成一张图片
目标企业主体的营业执照
微信小程序主体变更申请函，从变更资料那边下载，自己打印
自己手机号验证码
目标企业法人手机号验证码
修改服务类目，原服务类目会失效，我是先随便选了俩等通过认证之后再补
每年30块的认证费涨到300

变更函说明

需要目标企业的盖两个章，一个骑缝章
原个人主体需要签字和印手印

第一次提交失败

一个是应该使用原始id，这个没注意看弄错了，我申请函上使用的是小程序id

还有一个就是签字处要按手印，只能让我哥把文件寄过来。

第二次整改提交

整改后的变更函只需要发送到专员的邮箱即可，不用再在网页上进行操作。
提交第二天给我打了电话确认，先是人工询问一次信息，然后电子播报一次规则，最后再一次人工询问有什么问题。至于为什么是两次，因为我的变更函上手欠原管理员和目标管理员都写得自己，实际上目标管理员可以留空。我没留空得结果就是第一次电话过来之后又来了一个一模一样得电话，还是那个审核专员😂说实话有点死板。

变更成功

微信小程序开发，下载图片到系统相册并重命名文件名称的方法

2024-08-05T06:15:00.000Z

最近一直在开发小程序，做了一个自动抠图的功能。很多人可能需要将照片的背景去除，但是又不会ps怎么办？这个一键抠图就是解决这个问题。

我的预想是将自动抠图的照片保存为output_原文件名的形式。所以有了以下代码步骤: wx.downloadFile -> wx.getFileSystemManager().rename -> wx.saveImageToPhotosAlbum

原代码方法:

downloadImage() {  
    const that = this;  
    if (!this.data.resultImageSrc) {  
        wx.showToast({  
            title: '没有可下载的图片',  
            icon: 'none'  
        });  
        return;  
    }  
  
    const fileName = app.utils.extractFileNameFromUrl(this.data.resultImageSrc);  
  
    wx.downloadFile({  
        url: this.data.resultImageSrc,  
        success(res) {  
            if (res.statusCode === 200) {  
                const tempFilePath = res.tempFilePath;  
                const newFilePath = `${wx.env.USER_DATA_PATH}/${fileName}`;  
  
                wx.getFileSystemManager().rename({  
                    oldPath: tempFilePath,  
                    newPath: newFilePath,  
                    success() {  
                        wx.saveImageToPhotosAlbum({  
                            filePath: newFilePath,  
                            success() {  
                                wx.showToast({  
                                    title: '图片下载成功',  
                                    icon: 'success'  
                                });  
                            },  
                            fail() {  
                                wx.showToast({  
                                    title: '保存图片失败',  
                                    icon: 'none'  
                                });  
                            }  
                        });  
                    },  
                    fail() {  
                        wx.showToast({  
                            title: '重命名文件失败',  
                            icon: 'none'  
                        });  
                    }  
                });  
            } else {  
                wx.showToast({  
                    title: '下载图片失败',  
                    icon: 'none'  
                });  
            }  
        },  
        fail() {  
            wx.showToast({  
                title: '请求下载失败',  
                icon: 'none'  
            });  
        }  
    });  
}

在开发环境中测试是正常的，图片能够正常重命名并且也能够下载下来。结果上线后发现实际并不能正常下载😂

一翻查找资料之后发现保存系统相册重命名还不能使用wx.getFileSystemManager().rename,遂对代码进行调整如下:

wx.downloadFile({  
    url: this.data.resultImageSrc,  
    filePath: `${wx.env.USER_DATA_PATH}/${fileName}`,  
    success(res) {  
        if (res.statusCode === 200) {  
            const tempFilePath = res.filePath;  
            wx.saveImageToPhotosAlbum({  
                filePath: tempFilePath,  
                success() {  
                    wx.showToast({  
                        title: '图片下载成功',  
                        icon: 'success'  
                    });  
                },  
                fail() {  
                    wx.showToast({  
                        title: '保存图片失败',  
                        icon: 'none'  
                    });  
                }  
            });  
        } else {  
            wx.showToast({  
                title: '下载图片失败',  
                icon: 'none'  
            });  
        }  
    },  
    fail() {  
        wx.showToast({  
            title: '请求下载失败',  
            icon: 'none'  
        });  
    }  
});

主要区别就是去除了wx.getFileSystemManager().rename这个重命名方法，而是直接在wx.downloadFile中添加重命名的文件名称即可。

做小程序自动抠图时遇到的问题，解决python中找不到指定的模块fbgemm.dll的方案

2024-08-05T02:10:00.000Z

发现问题

小程序做了个一键抠图的功能，使用的是开源模型RMBG。
但是在运行模型时出现问题，如下:

解决方法

答案是在油管上看到的，方法如下:

实现效果

本地demo

小程序

使用java开发了一个有毒可燃气体监测数据接收的服务端

2024-08-01T10:00:00.000Z

项目简介

这是一个服务端源码
使用的是hj212-2017协议进行传输
监测设备通过网线接交换机，以TCP传输
传输设备共监测7个点，其中3个点监测的是混合气体，4个点是单一因子
存在212中的因子使用212编码，混合及不存在的使用自定义编码
阈值根据中华人民共和国国家职业卫生标准GBZ 2.1—2019来定
只包含实时数据传输
实时数据为null使用平均值
实时判断是否监测数据超标，超标数据写入influxdb，消警时将该条数据的clearTime以消警时间填充。
实时数据和报警数据同步写入Redis，方便使用。
服务监听端口6000，为yml中的netty.port
服务默认端口server.port其实没啥用，因为不涉及web。我这边设置完全是公司开发的自动发布服务需要监听这个端口。

核心代码

首先是使用netty开发的TCP服务端

NettyServer

import com.lyc.toxicharmful.config.properties.NettyProperties;  
import io.netty.bootstrap.ServerBootstrap;  
import io.netty.buffer.ByteBuf;  
import io.netty.buffer.Unpooled;  
import io.netty.channel.ChannelFuture;  
import io.netty.channel.ChannelInitializer;  
import io.netty.channel.EventLoopGroup;  
import io.netty.channel.nio.NioEventLoopGroup;  
import io.netty.channel.socket.SocketChannel;  
import io.netty.channel.socket.nio.NioServerSocketChannel;  
import io.netty.handler.codec.DelimiterBasedFrameDecoder;  
import io.netty.handler.codec.string.StringDecoder;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.stereotype.Component;  
  
import javax.annotation.Resource;  
import java.net.InetSocketAddress;  
  
/**  
 * 类 NettyServer  
 * * @author ChenQi  
 * @date 2024/7/29  
 */@Slf4j  
@Component  
public class NettyServer {  
  
    @Resource  
    private NettyServerHandler nettyServerHandler;  
  
    @Resource  
    private NettyProperties nettyProperties;  
  
    public void start() throws InterruptedException {  
        // 引导辅助程序  
        ServerBootstrap b = new ServerBootstrap();  
        // 通过nio方式来接收连接和处理连接  
        EventLoopGroup group = new NioEventLoopGroup();  
        try {  
            b.group(group);  
            // 设置nio类型的channel  
            b.channel(NioServerSocketChannel.class);  
            // 设置监听端口  
            b.localAddress(new InetSocketAddress(nettyProperties.getPort()));  
            // 有连接到达时会创建一个channel  
            b.childHandler(new ChannelInitializer() {  
                @Override  
                protected void initChannel(SocketChannel ch) throws Exception {  
                    //解决连包问题  
                    ByteBuf delimiter = Unpooled.copiedBuffer("\r\n".getBytes());  
                    ch.pipeline().addLast(new DelimiterBasedFrameDecoder(16 * 1024, delimiter));  
                    ch.pipeline().addLast(new StringDecoder());  
                    // pipeline管理channel中的Handler，在channel队列中添加一个handler来处理业务  
                    ch.pipeline().addLast("myHandler", nettyServerHandler);  
                }  
            });  
            // 配置完成，开始绑定server，通过调用sync同步方法阻塞直到绑定成功  
            ChannelFuture f = b.bind().sync();  
            log.info("{} started and listen on {}", NettyServer.class.getName(), f.channel().localAddress());  
            f.channel().closeFuture().sync();// 应用程序会一直等待，直到channel关闭  
        } catch (Exception e) {  
            log.error("NettyServer start error", e);  
        } finally {  
            // 关闭EventLoopGroup，释放掉所有资源包括创建的线程  
            group.shutdownGracefully().sync();  
        }  
    }  
}

NettyServerHandler

import cn.allbs.hj212.enums.GBT16706;  
import cn.allbs.hj212.format.T212Generator;  
import cn.allbs.hj212.format.T212Mapper;  
import cn.allbs.hj212.model.HjData;  
import com.lyc.toxicharmful.service.MessageFactory;  
import com.lyc.toxicharmful.utils.MsgHandleUtils;  
import io.netty.buffer.ByteBuf;  
import io.netty.channel.ChannelFutureListener;  
import io.netty.channel.ChannelHandler;  
import io.netty.channel.ChannelHandlerContext;  
import io.netty.channel.ChannelInboundHandlerAdapter;  
import io.netty.channel.socket.SocketChannel;  
import lombok.AllArgsConstructor;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.stereotype.Component;  
import org.springframework.util.StringUtils;  
  
import java.io.StringWriter;  
import java.nio.charset.StandardCharsets;  
import java.time.LocalDateTime;  
import java.time.format.DateTimeFormatter;  
import java.util.Map;  
import java.util.Optional;  
import java.util.concurrent.ConcurrentHashMap;  
  
/**  
 * 类 NettyServerHandler  
 * * @author ChenQi  
 * @date 2024/7/29  
 */@Slf4j  
@ChannelHandler.Sharable  
@Component  
@AllArgsConstructor  
public class NettyServerHandler extends ChannelInboundHandlerAdapter {  
  
    private final MessageFactory messageFactory;  
  
    private static final Map channelMap = new ConcurrentHashMap<>();  
  
    /**  
     * 连接后回调  
     */  
    @Override  
    public void channelActive(ChannelHandlerContext ctx) throws Exception {  
        super.channelActive(ctx);  
        log.info("client:{} is connected", MsgHandleUtils.getIPPortString(ctx));  
    }  
  
    /**  
     * 接收到报文回调  
     */  
    @Override  
    public void channelRead(ChannelHandlerContext ctx, Object msg) {  
        try {  
            // 获取企业mn号与排口code对应编号  
            String msgStr = new String(msg.toString().getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);  
            log.info("{}接收到三废排口报文：{}", LocalDateTime.now().format(DateTimeFormatter.BASIC_ISO_DATE), msgStr);  
            T212Mapper mapper = new T212Mapper().enableDefaultParserFeatures().enableDefaultVerifyFeatures();  
            HjData data = mapper.readData(msgStr);  
            if (data == null || data.getCp() == null || !StringUtils.hasText(data.getMn())) {  
                log.error("缺少必要信息或格式不正确");  
                return;  
            }  
            if (Optional.of(data).map(HjData::getMn).isPresent()) {  
                channelMap.put(data.getMn(), (SocketChannel) ctx.channel());  
            } else {  
                log.info("传的报文中mn为空，关闭该通道");  
                ctx.channel().close();  
            }  
            if (GBT16706._91.value().equals(data.getSt())) {  
                log.info("数据{}", data);  
                messageFactory.systemAction(data);  
            } else {  
                log.info("数据储存{}", data);  
                messageFactory.hj212DataSave(data);  
            }  
        } catch (Exception e) {  
            log.error("处理报文发生异常{}", e.getLocalizedMessage());  
        }  
    }  
  
    /**  
     * 方法功能: 发送系统报文信息  
     *  
     * @param mn mn号  
     */  
    public void sengMess(String mn, String ms) {  
        SocketChannel sc = channelMap.get(mn);  
        StringWriter writer = new StringWriter();  
        try (T212Generator generator = new T212Generator(writer)) {  
            generator.writeHeader();  
            generator.writeDataAndLenAndCrc(ms.toCharArray());  
            generator.writeFooter();  
            // 查询redis中是否有需要发送的数据  
            ByteBuf encoded = sc.alloc().buffer(writer.toString().length());  
            encoded.writeBytes(writer.toString().getBytes("GBK"));  
            sc.writeAndFlush(encoded).addListener((ChannelFutureListener) future -> log.info("回复:{}", writer));  
        } catch (Exception e) {  
            log.error("数据发送失败");  
        }  
  
    }  
  
    /**  
     * 数据处理完成回调  
     *  
     * @param ctx  
     */  
    @Override  
    public void channelReadComplete(ChannelHandlerContext ctx) {  
        log.info("channelReadComplete{}", LocalDateTime.now());  
    }  
  
    @Override  
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {  
        //cause.printStackTrace();// 捕捉异常信息  
        // 出现异常时关闭channel  
        ctx.close();  
    }  
  
    /**  
     * 客户端断开连接回调  
     */  
    @Override  
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {  
        // channel失效处理,客户端下线或者强制退出等任何情况都触发这个方法  
        log.info("{} 断开连接", MsgHandleUtils.getIPPortString(ctx));  
        ctx.channel().close();  
        super.channelInactive(ctx);  
    }  
}

当然必不可少的项目启动时启动netty服务

@EnableAsync  
@EnableAllbsInflux  
@SpringBootApplication  
public class PcToxicAndHarmfulApplication implements CommandLineRunner {  
  
    @Resource  
    private NettyServer nettyServer;  
  
    public static void main(String[] args) {  
        SpringApplication.run(PcToxicAndHarmfulApplication.class, args);  
    }  
  
    @Override  
    public void run(String... args) throws Exception {  
        nettyServer.start();  
    }  
  
}

业务逻辑

import cn.allbs.hj212.model.CpData;  
import cn.allbs.hj212.model.HjData;  
import cn.allbs.hj212.model.Pollution;  
import cn.allbs.influx.InfluxTemplate;  
import com.lyc.toxicharmful.config.enums.GasType;  
import com.lyc.toxicharmful.dto.AlarmFieldDTO;  
import com.lyc.toxicharmful.utils.DateUtil;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.data.redis.core.RedisTemplate;  
import org.springframework.stereotype.Service;  
  
import javax.annotation.Resource;  
import java.math.BigDecimal;  
import java.text.SimpleDateFormat;  
import java.time.LocalDateTime;  
import java.time.ZoneOffset;  
import java.time.format.DateTimeFormatter;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
import java.util.Optional;  
import java.util.concurrent.TimeUnit;  
  
import static com.lyc.toxicharmful.config.constant.CacheConstant.TOXIC_AND_HARMFUL_DATA;  
import static com.lyc.toxicharmful.config.constant.CacheConstant.TOXIC_AND_HARMFUL_DATA_ALARM;  
import static com.lyc.toxicharmful.config.constant.CommonConstant.*;  
  
/**  
 * 类 MessageFactoryImpl  
 * * @author ChenQi  
 * @date 2024/7/29  
 */@Slf4j  
@Service  
public class MessageFactoryImpl implements MessageFactory {  
  
    @Resource  
    private RedisTemplate redisTemplate;  
  
    @Resource  
    private InfluxTemplate influxTemplate;  
  
    @Override  
    public void hj212DataSave(HjData hjData) {  
        log.info("接收到的212数据{}", hjData);  
        // 储存influxdb  
        Map tags = new HashMap<>();  
        Map fields = new HashMap<>();  
        tags.put("mn", Optional.ofNullable(hjData).map(HjData::getMn).orElse(""));  
        tags.put("qnTime", Optional.ofNullable(hjData).map(a -> DateUtil.timeFormatWithMs(a.getQn())).orElse(""));  
        tags.put("dataTime", Optional.ofNullable(hjData).map(HjData::getCp).map(CpData::getDataTime).map(DateUtil::timeFormat).orElse(""));  
        redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA + Optional.ofNullable(hjData).map(HjData::getMn).orElse(""), "time", LocalDateTime.now().format(DateTimeFormatter.ofPattern(NORM_DATETIME_PATTERN)));  
        if (Optional.ofNullable(hjData).map(HjData::getCp).map(CpData::getPollution).isPresent()) {  
            redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA + hjData.getMn(), "time", LocalDateTime.now().format(DateTimeFormatter.ofPattern(NORM_DATETIME_PATTERN)));  
            hjData.getCp().getPollution().forEach((key, value) -> {  
                Optional rtd = Optional.ofNullable(value.getRtd());  
                Optional avg = Optional.ofNullable(value.getAvg());  
                if (rtd.isPresent() || avg.isPresent()) {  
                    BigDecimal valueToCheck = rtd.orElseGet(avg::get);  
                    fields.put(key, valueToCheck);  
                    // redis储存实时数据  
                    try {  
                        redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA + hjData.getMn(), key, valueToCheck);  
                    } catch (Exception e) {  
                        log.error("保存212实时数据失败,数据{},原因{}", hjData, e.getLocalizedMessage());  
                    }  
                    checkAndHandleAlarm(key, valueToCheck);  
                }  
                fields.put(key + "_flag", Optional.of(value).map(Pollution::getFlag).orElse(null));  
                fields.put(key + "_SampleTime", Optional.of(value).map(Pollution::getSampleTime).orElse(null));  
            });  
        }  
        influxTemplate.insert(DB_TOXIC_AND_HARMFUL_DATA, tags, fields);  
    }  
  
    /**  
     * 检查是否报警  
     *  
     * @param key   key  
     * @param value value  
     */    private void checkAndHandleAlarm(String key, BigDecimal value) {  
        for (GasType factor : GasType.values()) {  
            if (key.equals(factor.getCode())) {  
                if (value.compareTo(BigDecimal.valueOf(factor.getLevelTwoThreshold())) >= 0) {  
                    log.warn("报警: {} 超过二级阈值 {}", key, factor.getLevelTwoThreshold());  
                    sendAlarmAsync(key, value, 2, factor);  
                } else if (value.compareTo(BigDecimal.valueOf(factor.getLevelOneThreshold())) >= 0) {  
                    log.warn("报警: {} 超过一级阈值 {}", key, factor.getLevelOneThreshold());  
                    sendAlarmAsync(key, value, 1, factor);  
                } else {  
                    log.info("正常: {} 未超过阈值", key);  
                    // 消警  
                    clearAlarmAsync(key, factor.getName());  
                }  
                break;  
            }  
        }  
    }  
  
    /**  
     * 发送报警数据  
     *  
     * @param key    因子编码  
     * @param value  监测值  
     * @param level  等级 1级 2级  
     * @param factor 枚举  
     */  
    public void sendAlarmAsync(String key, BigDecimal value, Integer level, GasType factor) {  
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern(NORM_DATETIME_PATTERN));  
        try {  
            if (Boolean.FALSE.equals(redisTemplate.hasKey(TOXIC_AND_HARMFUL_DATA_ALARM + key))) {  
                redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA_ALARM + key, "startTime", time);  
                redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA_ALARM + key, "name", factor.getName());  
                redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA_ALARM + key, "unit", factor.getUnit());  
                // 不存在则新增influxdb数据  
                // InfluxDB报警数据  
                Map tags = new HashMap<>();  
                Map fields = new HashMap<>();  
                tags.put("code", key);  
                tags.put("name", factor.getName());  
                fields.put("value", value);  
                fields.put("alarmTime", time);  
                fields.put("unit", factor.getUnit());  
                fields.put("level", level);  
                // 额外添加type, 0为报警 1为消警  
                fields.put("type", 0);  
                fields.put("threshold", factor.getLevelOneThreshold() * level);  
                fields.put("content", String.format("监测点位%s编号%s于%s发生%s级报警,报警值%s%s,报警阈值%s%s", factor.getName(), key, time, level, value, factor.getUnit(), factor.getLevelOneThreshold() * level, factor.getUnit()));  
                influxTemplate.insert(DB_TOXIC_AND_HARMFUL_ALARM, tags, fields);  
            }  
            // Redis报警数据  
            redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA_ALARM + key, "level", level);  
            redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA_ALARM + key, "value", value);  
            redisTemplate.opsForHash().put(TOXIC_AND_HARMFUL_DATA_ALARM + key, "threshold", factor.getLevelOneThreshold() * level);  
  
        } catch (Exception e) {  
            log.error("发送报警数据失败, key: {}, value: {}, level: {}, 原因: {}", key, value, level, e.getLocalizedMessage());  
        }  
    }  
  
    /**  
     * 清除报警  
     *  
     * @param key key  
     */    public void clearAlarmAsync(String key, String name) {  
        if (Boolean.TRUE.equals(redisTemplate.hasKey(TOXIC_AND_HARMFUL_DATA_ALARM + key))) {  
            log.info("移除{}报警缓存，添加消警时间", key);  
            // 移除redis报警  
            redisTemplate.delete(TOXIC_AND_HARMFUL_DATA_ALARM + key);  
            // 获取当前点位未消警的报警数据,删除后插入带有结束时间的数据  
            String command = "SELECT * FROM " + DB_TOXIC_AND_HARMFUL_ALARM + "\n" +  
                    "WHERE \"code\" = '" + key + "' AND \"type\" = 0\n" +  
                    "ORDER BY time DESC\n" +  
                    "LIMIT 1";  
            List dataList = influxTemplate.queryBeanList(command, AlarmFieldDTO.class);  
            // 修改数据  
            if (!dataList.isEmpty()) {  
                AlarmFieldDTO fieldDTO = dataList.get(0);  
                Map tags = new HashMap<>();  
                tags.put("code", key);  
                tags.put("name", name);  
                Map fields = new HashMap<>();  
                fields.put("value", fieldDTO.getValue());  
                fields.put("alarmTime", fieldDTO.getAlarmTime());  
                fields.put("unit", fieldDTO.getUnit());  
                fields.put("level", fieldDTO.getLevel());  
                fields.put("threshold", fieldDTO.getThreshold());  
                fields.put("content", fieldDTO.getContent());  
                fields.put("type", 1);  
                fields.put("clearTime", LocalDateTime.now().format(DateTimeFormatter.ofPattern(NORM_DATETIME_PATTERN)));  
                // 移除原数据  
                influxTemplate.query("DELETE FROM " + DB_TOXIC_AND_HARMFUL_ALARM + " WHERE time = '" + new SimpleDateFormat(UTC_MS_WITH_ZONE_OFFSET_PATTERN).format(fieldDTO.getTime()) + "'");  
                // 增加数据  
                influxTemplate.insert(DB_TOXIC_AND_HARMFUL_ALARM, tags, fields, fieldDTO.getTime().getTime(), TimeUnit.MILLISECONDS, ZoneOffset.of("+08:00"));  
            }  
        }  
    }  
  
    @Override  
    public void systemAction(HjData hjData) {  
        log.info("执行系统指令{}", hjData);  
    }  
}

引入的两个处理jar包说明

allbs-hj212 参考代码https://github.com/tracy4262/hj212.git自己重新做了封装，且发布到了maven公共库便于引入使用。用来处理hj212报文协议，解析数据
allbs-influx 自己做的influxdb相关操作的封装，地址https://github.com/chenqi92/allbs-influx.git也上传至maven公共库中便于引入，如果你们需要可以使用2.0.2版本，2.1.0版本没测所以使用有点问题，后面会修改并且增加一些便捷方法。

源码地址

我上面的核心代码并不完整，可以直接去看源码。如果对你有用，给个star哦😘源码地址:

https://github.com/chenqi92/pc-toxic-and-harmful.git

做了一个上线就瘸腿的小程序

2024-07-31T05:41:00.000Z

本来预想第一个版本只做两个功能：

微信内无法预览的文件类型做个预览的功能
热点新闻一网打尽，直接在小程序内看各平台的新闻热点。

然后发现现实是残酷的，个人认证的开发功能是不全的😂如果想要完整功能，还得去注册一家企业来开通更多功能，当然认证费用也由个人的30块涨到300块。。

下面做个功能介绍

文件预览

相信很多人都遇到过微信无法直接打开某些类型的文件，比如CAD的dwg，使用起来很不方便。我这个功能就是选择某个群聊中的文件直接在小程序中完成浏览。
效果如下，左侧是选取文件，右侧是直接在小程序中浏览的效果。

但是，没想到个人认证的用户功能受限。想使用这个功能还得从小程序切出来在浏览器中看🤣未上线就瘸腿了。

新闻热点总#览

效果如下，就是把各平台的新闻热点做了个聚合。考虑到上面的个人类型权限首先所有也无法直接跳转看原文了。

但是没想到这次是直接没法通过：

只能将功能完全砍掉了。。。

后续预想添加的功能

照片裁剪，更换背景色，使其形成1寸、2寸照片
OCR识别(具体做什么功能没想好，比如扫彩票查看中了多少？)
其他语言书籍翻译
英语单词训练做个排名？

小程序扫码体验

在当代互联网生态中如何有效的查询你所需要的知识，谷歌、必应、百度、公众号、各视频平台数据得有效性

2024-07-23T03:41:00.000Z

起因

知乎刷到一篇文章,如下：

看了很多评论，发现了一个很核心的问题，大家无法从现代极度发达的互联网生态中找到自己真正想要的内容，会被大量无用的信息所干扰。那么我们就试着搜索一下想要的内容，看有东西有多少是可用的，有多少是干扰的垃圾信息。

以热榜的国家食品标准为例，查找相关信息。

百度

搜索中国食品安全标准得到的信息如下:

整个首页除了底部最后是一个政府官网，其他要么就是百度系的不知所谓的内容，要么就是非官方的若干年前的新闻。秉着只信任官方的原则，点开第一页的最后一个链接，内容如下：

好吧，这样的内容明显是不符合我们想要的内容的。

那么我们按照顺序从上往下找，第一个是百度百科，这种东西图个乐，你们自己点开就知道没啥有价值的内容了。然后点击排名第二的链接，发现居然是被告😂，点开后有详细的名称和执行标准，如下:

其实有了标准我们就好查阅相关内容了，比如我们查找食品添加剂的使用标准：

可以看到首页依然只有一个政府相关网站，就是宁津县人民政府的网页。虽然依旧是大量的非官方网站，以让你付费下载的目的做展示，但是至少有一个政府网页能排前三了🤣

Google

作为一个非国内运营的网站，很多人口中十多年前被百度打的抱头鼠窜的搜索引擎，我们来看下表现如何：

展示内容基本全是我国政府网站信息，和百度系一比，一切尽在不言中。

我们继续点开第一个链接，发现能够轻松找到今年的官方的食品执行标准，从标准号中的年份可以看到，这个标准要比上方能找到的标准要新的，上方的标准落后十年。当然我不是做食品行业的，也不知道这个标准是不是同一个类，但是从名称和Gb2760来看应该是同一个。标准内容如下：

我们继续按照上方百度的查找方法，继续查找食品添加剂标准:

能够看到依然是能够轻松的找到具体执行标准的，但是显示的主要还是英文内容，这点表现很差，我们必须加入限定词如中文GB 2760-2024搜索内容如下:

除了第一项政府官方只有一个名称外，其他链接都是能直观展示协议内容的。好吧，官方信息反而成为一个阻碍了😅

从目前来看，一个境外的搜索引擎是完爆了百度的，现在还是AI时代，百度存在的意思是不是剩下看新闻和看广告了？哦对了，还有大量的内容农场。。。。

bing

考虑到国内使用谷歌有一道门槛，我们继续用第三个搜索引擎bing来试试

结果如下,第一项是2023年的内容，里面的标准依然是2014年的。第二项为今年的内容，执行标准为2024年，从这点来看结果还不错。其他链接我也点开了，有点牛头不对马嘴。。。虽然比不上谷歌，也可能产生错误的判断，但是有心人还是能找到想要的结果的，就是有一定门槛。

依然是搜索同一个内容:

公众号

还是一样的搜索标准，能够明确的看到想要的搜索结果，而且是最新的内容。说实话这个结果还是挺不错的。

小红书、抖音等视频平台

有东西，但不多。没有花费时间的必要

结论

根据以上的搜素结果可以得到一定的结论，虽然不代表所有的搜索内容都如此，但是可以参照。

考虑到微信公众号有一些我这种自媒体，其中的消息会有失真，所以我最终给出的结果是:

谷歌 ≥ 公众号 > bing > 百度 > 视频平台

制作一个多系统的启动u盘,便与重装各种系统

2024-07-15T01:00:00.000Z

简介

在日常生活和工作中，我们常常需要安装不同的操作系统或在不同系统之间切换。传统的U盘启动盘制作方式需要不断格式化和写入新的镜像文件，既耗时又繁琐。现在我们这个开源免费的工具就是为了解决这些问题而出现。Ventoy是一款开源的工具，能够让你在U盘上直接启动ISO、WIM、IMG、VHD(x)、EFI文件，而无需每次都格式化U盘。你只需将这些镜像文件复制到U盘中，就可以通过Ventoy来选择启动哪个操作系统。

准备工作

在开始之前，你需要准备以下物品和软件：

一个容量足够大的U盘（建议至少16GB）
需要启动的操作系统镜像文件（例如Windows、Linux、CenterOs等）
Ventoy软件（可从Ventoy官网下载）

制作步骤

1. 下载并安装Ventoy

首先，从Ventoy官网下载最新版本的Ventoy工具包。下载完成后，解压文件，并根据你的操作系统选择相应的版本（Windows、Linux）。
比如我windows就下载:

2. 安装Ventoy到U盘

插入U盘，并确保U盘中没有重要数据，因为接下来的步骤会格式化U盘。
运行Ventoy2Disk.exe（Windows系统）或ventoy2disk.sh（Linux系统）。
在Ventoy界面中选择你的U盘设备，并点击“Install”按钮。

Ventoy会自动选择你的U盘，如果没有查询到则点击左上角配置选项->显示所有设备这样可以把你所有储存都显示出来，但是一定要注意不要把自己电脑硬盘给格了！！！

确认安装操作，Ventoy会自动格式化并安装到U盘中。

3. 复制镜像文件到U盘

Ventoy安装完成后，你会发现U盘中有一个名为Ventoy的分区。现在，你只需将准备好的ISO、WIM等镜像文件直接复制到这个分区中即可。
可以选择多个镜像文件拷贝进u盘

4. 启动U盘并选择操作系统

将U盘插入目标电脑，启动电脑并进入BIOS设置，选择从U盘启动。Ventoy界面会显示你复制到U盘中的所有镜像文件，你只需选择你想要启动的操作系统即可。

使用示例

进入bios

将u盘插入需要重装系统的设备中。开机按Delete键，一般都是这个键，如果不行可以尝试F1、F11、F12之类的，进入bios。

将u盘启动调整为第一顺序

保存并推出

选择你想安装的系统

完成安装

搭建一个精灵宝可梦的安卓、IOS双端的体验服，体验氪金大佬的感觉

2024-07-13T01:23:00.000Z

[前言]
重要的事情说三遍，不要将本资源用于商业行为！不要用于商业行为！不对您的使用负任何责任！本文章以及资源仅供学习研究传播！

前言

又到周末了，又可以愉快的玩游戏了。但是市面上手游不充值毫无体验，不如就自己搭一个手游私服给小伙伴们爽一下。当然我自己的云服务器小水管支持不了太多人，所以将完整的搭建方法提供出来。有兴趣的话h可以跟着复现一下，和你们的小伙伴们一起愉快的玩耍。

效果图

体验

首先进行账号注册
注册地址:
http://121.40.70.175:88/

安装包给我公众号发宝可梦即可

Ubuntu服务器设置指南

更新源

为了加快安装速度，建议将 apt 和 pip 源更换为腾讯源或者阿里源。

# 切换到root用户
sudo -i
# 更新源
apt-get update
# 安装ssh 我这只是为了不想在虚拟机中操作，所以才安装。如果你一直在虚拟机中或者云服务器中操作，可以不用这步
sudo apt-get install openssh-server
# 启用ssh
systemctl start ssh
# 开机启用
systemctl enable ssh

安装所需软件包

apt-get install expect subversion build-essential lib32stdc++6 gcc-multilib g++-multilib python-dev pypy-dev gdb python2.7-dbg libcurl4-openssl-dev graphviz openssl libssl-dev swig gawk iotop lsof iftop ifstat iptraf htop dstat iotop ltrace strace sysstat bmon nethogs silversearcher-ag libsasl2-2 sasl2-bin libsasl2-modules python-setuptools luajit curl wget unzip python-pip

添加 MongoDB 密钥和源

1
2

apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 2930ADAE8CAF5059EE73BB4B58712A2291FA4AD5
echo "deb http://repo.mongodb.org/apt/debian jessie/mongodb-org/3.6 main" | tee /etc/apt/sources.list.d/mongodb-org-3.6.list

安装宝塔面板便于操作

如果是老手，完全可以不用安装

1	wget -O install.sh http://download.bt.cn/install/install-ubuntu_6.0.sh && sudo bash install.sh

输入 y 并按回车确认安装。

登录并绑定账号

设置宝塔面板环境

Nginx 1.18
MySQL 5.6
PHP 7.1

增加虚拟内存（如果内存不足）

在宝塔面板中：

进入软件商店 > 系统工具 > 安装 Linux 工具箱 > 增加虚拟内存

放行端口

如果是云服务器中：

进入安全组->放行端口: 1:65535

如果是在宝塔面板中：

进入安全 -> 放行端口：1:65535

关闭防火墙

1	sudo ufw disable

上传并解压服务端文件

资源关注我公众号IT日常发送宝可梦源码获取

1
2
3

# 上传 kdjx.tar.gz 到 /home/keke下,因为我虚拟机主机名称叫keke所以就是/home/keke,如果你的叫其他名字，就是/home/你的主机名称下
cd /home/keke
tar -zxvf kdjx.tar.gz

安装 MongoDB

sudo apt-get update
mv /home/keke/mongodb.tar.gz /
cd /
tar -zxvf mongodb.tar.gz
apt-get install mongodb-org=3.6.12 mongodb-org-server=3.6.12 mongodb-org-shell=3.6.12 mongodb-org-mongos=3.6.12 mongodb-org-tools=3.6.12

安装所需包：

pip install cython six lz4==0.8.2 numpy==1.16.0 xlrd xdot rpdb psutil fabric==1.7.3 pycurl pycrypto M2Crypto==0.36.0 objgraph msgpack-python backports.ssl-match-hostname Markdown toro pymongo pyrasite pyopenssl ThinkingDataSdk==1.4.0
pip install tornado==4.4.2
pip install Supervisor==3.3.0
pip install cryptography==2.6

移动配置文件

1
2
3

sudo mv /home/keke/default /etc/nginx/sites-available
sudo mv /home/keke/pokemon_server_test.tar.gz /mnt
sudo mv /home/keke/game.tar.gz /www/wwwroot

解压游戏文件

cd /mnt
tar -zxvf pokemon_server_test.tar.gz
cd /www/wwwroot
tar -zxvf game.tar.gz

重新加载 Nginx

1	nginx -s reload

设置权限

1 2	chmod 755 -R /mnt chmod 777 -R /www/wwwroot/

修改 IP 地址（任选一种方法）

方法一：快捷修改

find /mnt -type f -name '*.py' | xargs sed -i 's/192.168.0.120/你的ip/g'
find /mnt -type f -name '*.json' | xargs sed -i 's/192.168.0.120/你的ip/g'
find /mnt -type f -name '*.plist' | xargs sed -i 's/192.168.0.120/你的ip/g'
find /www -type f -name '*.plist' | xargs sed -i 's/192.168.0.120/你的ip/g'
find /www -type f -name '*.lua' | xargs sed -i 's/192.168.0.120/你的ip/g'
find /www -type f -name '*.view' | xargs sed -i 's/192.168.0.120/你的ip/g'

方法二：手动修改

在以下文件中搜索 192.168.0.120 并替换为你的 IP 地址：

/www/wwwroot/game/pokemon/patch/881/res/version.plist
/www/wwwroot/game/pokemon/patch/881/src/app.views.login.view
/www/wwwroot/zc/index.php
/mnt/pokemon/release/login/conf/dev/serv.json
/mnt/pokemon/release/login/conf/serv.json
/mnt/pokemon/release/login/defines.json
/mnt/pokemon/release/game_defines.py
/mnt/pokemon/release/payment_defines.py

更新 MD5 和文件大小

文件：`version.plist`

# 复制输出的 MD5 码
md5sum /www/wwwroot/game/pokemon/patch/881/res/version.plist 
# 获取文件大小
ls -l /www/wwwroot/game/pokemon/patch/881/res/version.plist

更新文件：

1 2	# 更新 MD5 和大小，然后保存退出 /mnt/pokemon/release/login/patch/cn/881.json

文件：`app.views.login.view`

# 复制输出的 MD5 码
md5sum /www/wwwroot/game/pokemon/patch/881/src/app.views.login.view  
# 获取文件大小
ls -l /www/wwwroot/game/pokemon/patch/881/src/app.views.login.view

更新文件：

1	/mnt/pokemon/release/login/patch/cn/881.json

创建网站

IP: 81，目录：/www/wwwroot/game/
IP: 88，目录：/www/wwwroot/zc/

修改数据库密码

修改为你自己能记得的密码

修改/www/wwwroot/sk文件中的密码为上面的数据库密码

导入数据库

1 2	cd /www/wwwroot ./sk

启动游戏

cd /mnt/pokemon/deploy_dev
rm supervisor.sock
supervisord -c supervisord.conf
supervisorctl start all
// 查看游戏状态
supervisorctl status

启用失败的单独重启

1	supervisorctl start xxx

停止游戏

1	supervisorctl reload

客户端修改

安卓

路径：\assets\res\version.plist
windows中直接使用winrar打开，然后将上述文件解压到本地，修改其中的ip为你自己的ip后在拖进去，最后使用签名工具签名即可。

直接拖到签名工具中签名

苹果

路径：\Payload\MyLuaGame.app\res\version.plist

注册和登录地址

下面的root123456是默认密码，可以自己去修改

注册地址：http://IP:88
管理后台登录：http://IP:31528/login （账号：admin，默认密码：root123456）
GM 授权后台：http://IP:81/gm/gm.php （默认GM 码：root123456）
玩家管理：http://IP:81/gm/ （默认GM 码：root123456）

安装

安卓可以直接装到手机或者在模拟器中安装游玩。
ios需要用爱思助手，使用自己的appleId自签名装入手机中，然后信任证书。

其他

修改服务器区域名称

文件：/mnt/pokemon/release/login/conf/serv.json

更新公告

文件：/mnt/pokemon/release/login/conf/cn/notice.json

苹果手机通过Loon跳过app开屏广告的教程

2024-07-11T06:00:00.000Z

视频

直接看视频就够了，如果有不清楚的看下面的图文教程。b站视频被举报下架了，所以就直接放了，但是因为服务器带宽小，所以可能会卡😂

图文教程

下载

需要使用apple的外区账号，官网注册可以跳过绑定支付方式。需要5.99美刀。

生成并安装证书

在设置 -> MitM的证书管理点击生成新的证书

安装证书

在iphone的设置 -> 通用 ->VPN与设备管理

信任证书

在设置 -> 通用 -> 关于本机 ->证书信任设置

重新打开Loon配置

将以下三项勾选上

导入插件

手机浏览器打开
https://whatshub.top/loon

点击去开屏广告融合版Ultra+自动跳转至Loon制动导入插件，导入完成后可以点击首页的插件查看。

最后打开总按钮就可以愉快的跳过广告啦

结语

这款意外之外是我ui体验最好的一款，功能、ui、交互都让我感觉挺舒服的😂

电梯卡、门禁卡等IC卡破解及复制教程

2024-07-10T01:41:00.000Z

[前言]
相信很多人有如下的烦恼：有时候忘记带电梯卡了，累死累活爬楼梯感觉掉了半条命。大半夜的忘记带门禁卡，顶着鄙视的眼神叫家人或者保安来开大门。那么有什么办法可以避免呢？考虑到日常手机是不离身的，那么就可以把数据写入手机的方式来解决。

背景

写这一篇文章纯粹是朋友突然问到相关的，我考虑了一下大众确实有类似的需求。

说实话我真没理解啥意思😂，但是本着平时跟客户沟通习惯了，就把所有方案列出来让她选就好了嘛。

安卓是最简单的，有写入nfc的功能，所以可以把破解后的卡复制到手机里面，通过手机开门。

苹果比较麻烦，没有nfc的写入功能，只能找比较薄的卡贴，把数据写入进去然后贴在手机上。或者有些apple watch表带中带芯片也可以写入。

首先我们来区分几种卡。卡也有种类，不同种类不同的用途，写入方式也不一样。下面这些卡的区分是自身理解不一定对，能够明白大概意思就行了。

ID卡，挺古老的，现在用的不多，一般就存个唯一的卡号，容易复制。以前估计用的多，用来识别不同人考勤之类的。只有特别古老的门禁估计会用，复制也是极简单的，都不用破解。
IC卡，应用挺多的电梯、公交卡、银行卡，主要是用作身份证明。适用高安全性和数据处理功能的场景，这也是现在大部分门禁用到的。本篇的目的就是对其破解、复制。
CUID卡，也就是下面我们主要会使用到的卡，安全性低，主要是为了克隆IC卡的唯一ID号（UID)，能够快速制作备用卡和复制卡，也就是上面破解数据的载体。
磁条卡、cpu卡、SIM卡就不说了，不用考虑到。

破解门禁

这边先说明一下，绝大多数小区的卡是可以破解的，个别除外。据我所知万科的卡没法破解，不过可以让他们帮忙配置到手机里。其他小区物业说不定都是一般年纪大的，让他们写卡，真不一定能搞定。

准备

首先要具备一个ic卡读写器，然后读卡器肯定会配备相应的软件，网上挺多的。买的时候要注意了！！！门禁或者电梯的IC卡也分代数，1&2代卡基本上市面产品读写器都能读出来，3代产品是需要厂家技术支持的，市面上并不是所有的读写器都能读出来！所以买的时候一定一定咨询清楚了！

我用的是这款

使用配套软件进行读卡

我用的是物业给的一年期门禁卡。最好是老卡(一或者二代卡)，因为卡升级了并不代表梯控或者门禁设备升级了，那玩意成本高，物业不一定舍得，使用老卡破解后是能够继续用的。
解码后内容如下，将数据保存到本地会得到一个.dump文件

破解数据

我用的是IC客栈（要收费还特贵），优点是不用自己去破解了😂

把.dump文件拖到左侧点自动分析或者VIP分析，可以解析出电梯卡或者门禁卡中的数据含义。

解析并修改

在一键修改栏、点击检测，能够得出卡中信息，以我家电梯卡为例：

注意！卡号和发卡号不要修改！改了可能用不了，改卡的到期时间和楼层即可。
点击时间图标可以把电梯卡延期到你想要的时间，比如我下面就改到了2070年。

第二个时间及楼层修改，下拉框选中第二个，可以看到下方的电梯号05和06，这个代表这个卡在小区能够控制我们这栋楼的编号为05、06两台电梯，右侧的楼层点开后可以修改刷上卡时电梯能够点击的楼层，我家是21楼，上面显示的是20，依次类推，勾选上你想去的楼层即可。修改完成后点击修改按钮左侧数据内容会被改掉，然后将左侧内容保存为一个新的.dump文件。

最后写入数据

破解并保存出来的是这样一个.dump文件

导入数据—>写入卡即可

写进手机

安卓

安卓因为具备NFC的写入功能，所以写起来很简单。打开卡包–>新建空白卡–>将卡贴在手机的NFC区域–>读卡并生成一张虚拟门禁卡。这个时候你就可以用手机来解锁门禁和梯控了。
手上没有安卓手机就不演示，之前用我妈的手机试过，挺简单的。

苹果

苹果没有写NFC的功能，所以网上那些用什么公交卡制作啊，快捷方式啊，全是扯淡的。
只有一个替代的方法，将破解后的数据写入CUID卡中，然后贴在手机壳上。卡的造型如下：

苹果手机通过圈X跳过app开屏广告的教程

2024-07-09T00:23:00.000Z

之前做了小火箭和surge的跳过教程，有小伙伴提出想要看圈X的，反正不差这一个就顺带做了下。具体用法如下:

操作视频

这是录得操作视频，可以直接跟着操作即可，有不清楚得可以看下面文字说明。本来是放b站想白嫖带宽的，可是被举报下架了，关键给的理由还很奇怪，说是分享出来大家都没法用了，这玩意本来就没在国区上架啊😂

文字教程

下载圈X

生成证书

先点生成证书，再点配置证书

默认浏览器必须是safari，配置描述文件

安装证书

通用->VPN与设备管理安装描述文件。

打开证书信任

打开通用->关于本机->证书信任设置

浏览器打开可以安装模块的网站

网站链接:

https://whatshub.top/quantumultx

实际上这个网站模块功能特别多，字面意思理解，跟跳广告的一样的安装形式，自取所需即可。

圈X开始安装模块

可以看到左上角已经在安装了

开启功能

先打开MitM和重写开关。

最后打开主开关并添加VPN

全部完成后不出意料就可以跳过广告了，具体可以查看视频的演示。

搭建一个安卓、ios双端可玩的海贼王手游，含GM工具

2024-07-07T01:23:00.000Z

[前言]
重要的事情说三遍，不要将本资源用于商业行为！不要用于商业行为！本文章以及资源仅供学习研究传播，后续软件使用过程发生的一切问题与我无关哦。

资源的获取

给本公众号IT日常发送海贼王即可，请尽快转存，我分享的资源将不定时修改分享链接！

开始搭建

推荐使用虚拟机装，不容易出问题。云服务器和虚拟机除了需要在安全组多开点端口没啥区别。

虚拟机用的是CenterOs，如果需要安装包给本公众号发送centeros即可。

虚拟机网络需要设置主机模式，保证跟家里设备网络同在一个网段。

固定一下虚拟机的ip便于远程连接。因为我家的网段设置的是0，所以有以下配置，根据你们实际情况配置即可。

首先安装宝塔面板

这个只是为了简化一些使用者的操作，并不是必须的，可以自己单独安装Nginx 1.18,MySQL 5.6,php 7.0。

1	yum install -y wget && wget -O install.sh https://download.bt.cn/install/install_6.0.sh && sh install.sh

安装完成之后如下

开放端口

记得宝塔和安全组的端口都打开1:65535，我的服务器主要快到期了，什么脚本小子也就无惧了。当然你可以根据需要只打开所需端口。

关闭防火墙
好同学莫学我，虚拟机或者你的服务器也快到期的话可以这么干。

1 2	systemctl stop firewalld.service systemctl disable firewalld.service

上传资源

将分享给你的文件data.zip上传到服务器根目录

解压

1	unzip data.zip

授权

1	chmod -R 777 /data

安装erl环境

cd /usr/lib && tar -zxvf allbs.tgz

# 使其生效
source /etc/profile

重启nginx

修改服务端代码ip

使用notepad++的文件查找替换工具将所有的192.168.0.120替换为你部署服务器的ip

或者手动将这几个文件中的ip替换为你实际的ip

修改文件中的数据库root密码

修改服务器配置文件中的密码，如果你不想修改文件则这边设置root123456，内网无所谓，云服务器一定要注意安全！最好是进行文件替换！
如下文件中所有匹配root123456的全部替换为你上面设置的密码

data\sszg_code\v200408\server\tpl\ctl.sh

data\sszg_code\www\ht\config.php

data\sszg_code\www\_init.php

data\zone\sszg_center_6\ctl.sh

data\zone\sszg_symlf_1\ctl.sh

data\sszg_code\v200408\server\tpl\ctl.sh

data\zone\sszg_symlf_2\ctl.sh

安装节点

1
2
3

/data/zone/sszg_center_6/ctl.sh install
/data/zone/sszg_symlf_1/ctl.sh install
/data/zone/sszg_symlf_2/ctl.sh install

安装`screen`

这个主要是为了会话共享，开多个区用的

1	yum install screen -y

启动游戏

输入命令screen

开区

1
2
3

/data/zone/sszg_center_6/ctl.sh start 
/data/zone/sszg_symlf_1/ctl.sh start
/data/zone/sszg_symlf_2/ctl.sh start

查看是否启动

1	netstat -ntlp

如果有这些端口说明启动成功了，不一定都需要

关闭游戏

1
2
3

/data/zone/sszg_center_6/ctl.sh stop
/data/zone/sszg_symlf_1/ctl.sh stop
/data/zone/sszg_symlf_2/ctl.sh stop

如果没有启动成功

执行erl查看是否显示command not found，如果出现
手动在/etc/profile中添加

1	export PATH=$PATH:/usr/lib/erlang/bin

再执行

1	source /etc/profile

手机客户端修改

直接使用winrar打开apk文件

找到文件\assets\HASH\3\39F8AABC9BDC5AD4.lua和\Payload\太平洋堡垒战·热血航线.app\HASH\3\39F8AABC9BDC5AD4.lua解压到本地后解密后修改其中的ip并重新加密再丢进压缩包中替换即可

安卓的位置

ios的位置

解密方法

放在同一个目录下，双击批量解密.cmd，这样lua文件就可以进行ip替换了。

替换的是这个192.168.0.120这个ip

加密方法

最后拖到压缩包中替换该文件就可以了,最后就是拖到手机里面安装了。

GM后台

如果访问不了801端口可以在宝塔中配置后台的nginx代理

访问玩家后台

http://192.168.0.120:801/ht/

超管后台
http://192.168.0.120:801/ht/gz.php

GM认证码我设置的是和数据库一个密码，如果上面全部替换的话就会是数据库同密码。

游玩截图

版本更新的提示直接叉掉或者点跳过。记得使用邮箱注册，不要用手机号。

注意！不要进行微信和支付宝支付！我未修改代码将这两项去除，可以使用GM给玩家充值欢乐币，玩家接口使用欢乐币购买各种VIP礼包！

不想搭建，只想体验？

可以用我搭好的现成的来玩，但是不建议，因为随时可能会停服，而且服务器也没几个月了。微信给本公众号IT日常发送海贼王apk就会给你安卓应用链接，直接安装即可。给本公众号IT日常发送海贼王ipa即可获得苹果的下载链接。苹果安装挺麻烦的，安装过程可以查看我公众号历史文章。

2024年发布到maven中心库的新方式

2024-07-04T01:25:00.000Z

[前言]
之前写过若干java开发时简化操作或者是拓展功能的工具包，因为懒好久没更新了。最近因为个别项目里面使用时出现应用场景不太够就更新了一波。本打算立刻发布到maven的中心库中以便引入，突然发现发不上去了！于是有了以下调查内容。

背景

发布时出现401错误

Remote staging finished with a failure: Failed to deploy artifacts: Could not transfer artifact cn.allbs:allbs-influx:jar:javadoc:2.1.0 from/to sonatype-nexus-snapshots (s01.oss.sonatype.org:443/service/loc…): status code: 401, reason phrase: Content access is protected by token (401)

登录仓库查看

仓库中缺少很多包的信息，只有很久没更新过的包残存在上面。

管理端查看

查了一下自己仓库，发现包其实是上传上来了，但是关闭并发布是不起效果的。考虑了一下可能又换仓库了，想起官方访问页面之前是变了样式得，也和这种可能性相和。这样得话只能去官方找资料查看了。

开始解决

官网上的说明文档

链接如下：
https://central.sonatype.org/faq/what-is-different-between-central-portal-and-legacy-ossrh/

大致可以看出旧版和新版并不兼容，同时旧版的命名空间并不能带入到新版之中，如果要迁移必须写邮件申请。

开始转移namespace

注意这些操作全是基于你在旧版上注册过！以下邮件的红色内容需要替换为你自己实际信息，不要照抄。

主题：Request for Namespace Migration to OSSRH
邮件接收方：central-support@sonatype.com
内容参考:

Dear Central Support Team,

I am writing to request the migration of my namespace from OSSRH to the Central Portal. Below are the details of my account and the namespace I wish to migrate:

- **Account Information:**
    
    - Username: [你的旧版账号]
    - Email: [账号绑定的邮箱]
- **Namespace(s) to Migrate:**
    
    - 你的namespace

The reason for this migration request is to facilitate the version iteration and maintenance of our existing functionality packages. We believe that migrating to OSSRH's Central Portal will provide better management capabilities and access to new features that will enhance our development and deployment processes.

I appreciate your assistance with this request and look forward to your response. Please let me know if any additional information is required.

Thank you.

Best regards,  
[你的姓名]  
[你的联系方式]

没几分钟就能收到对方的回复邮件，其实下面这种图是第一次我发邮件内容不清晰的后回复的图片😂。
ps:我这篇文章最开始发在掘金的，其实邮件内容是错的，有其他公众号照抄其实也错了😂。

内容需要更正一下发送可以抄上面英文邮件内容，不要抄上面图片内容。得到的结果如下：

新版maven central中的记录：

修改deploy至新库

首先是获取userToken

新的maven公共库和以前的方式不同，deploy需要发布的用户名和token

修改maven的setting.xml

java的pom.xml中的修改

主要是两处地方
一是：

第二处：

执行deploy看看效果

能推入库中说明以上配置已经生效了，但是因为namespace还未从旧版移过来所以发布失败了。下面只需要安心等待即可。

对接化工园区卡口地磅，使用java开发通过串口读取地磅称重数据全过程说明，内附源码

2024-07-02T02:09:00.000Z

[背景]
化工园区封闭化建设，出入需要称重，所以加装了地磅。现有两个卡口，每个卡口进出分别各有一个地磅，每个卡口配一台主机，两个地磅都直接连接到电脑主机上，仪表232接电脑串口（仪表15芯7、8接电脑九芯2、5）。业务需求是提供一个接口能够读取指定地磅的实时数据，所以就开发一个程序部署在这台主机上读取串口数据并往外提供最新数据。

准备工作

因为本身并没有出差去现场，加上他们不知道应该怎么把地磅和主机接起来，所以远程跟运维沟通了下，现场发来卡口主机接口如下:

我一看，以我贫瘠的硬件知识来说貌似也没太多选择，买俩usb转485线应该就可以了。然后打开京东，搜索485转USB打开第一家，转发物品链接，让运维去采购好了。（其实我觉得这线绝对贵了很多，不过也不用我掏钱，也懒的再去找了😂）

过了一个周末，线到了。开始配合现场调试数据，听说现场调试地磅的还是一个60多的老前辈，指着串口返回的一堆二进制的00数据跟我说地磅调试正常了。我是一脸懵逼，这和报文协议咋不一样，而且这二进制的00能解析出啥？这个时候我是有点开始怀疑自己了，难道是报文协议看漏了，还是我用的串口工具有问题啊，还没等我安装上另外的串口工具，结果老前辈发消息来说是线没接上🥴。我估摸着有点扯淡的，线没接也打不开串口啊，当然也有可能是其他部件的线没接上导致数据不是正常数据。反正是经过一通折腾，终于有正经的数据返回了。

报文协议

文档的链接为:
https://nas.allbs.cn:8888/cloudpic/2024/07/c530a6c79d0d846679f9e3a4aade3a88.pdf

主要核心内容包含如下:

源码说明

因为只会java所以就用java写的，其实要是用go的话代码应该会简略很多，想了想以后再学吧，现在用java写写得了。

引入核心串口通讯依赖

  
    com.fazecast  
    jSerialComm  
    2.11.0

串口打开、关闭、发送数据、接收数据的类开发

每个方法的作用详细见方法注释，初始化时会遍历所有可以打开的串口，并将串口储存在map中便于后续的使用。

package cn.allbs.weightscale.config;  
  
import cn.allbs.weightscale.exception.BhudyException;  
import cn.allbs.weightscale.handler.SerialPortListener;  
import cn.allbs.weightscale.util.SerialPortUtil;  
import com.fazecast.jSerialComm.SerialPort;  
import jakarta.annotation.PostConstruct;  
import jakarta.annotation.Resource;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.data.redis.core.RedisTemplate;  
import org.springframework.stereotype.Component;  
  
import java.io.ByteArrayOutputStream;  
import java.time.LocalDateTime;  
import java.util.HashMap;  
import java.util.Map;  
import java.util.Optional;  
  
/**  
 * 类 SerialPortManager  
 * * @date 2024/6/27  
 */
@Slf4j  
@Component  
public class SerialPortManager {  
  
    private final Map serialPorts;  
    private final Map listeners;  
  
    @Resource  
    private RedisTemplate redisTemplate;  
  
    @Resource  
    private SerialPortConfig serialPortConfig;  
  
    public SerialPortManager() {  
        serialPorts = new HashMap<>();  
        listeners = new HashMap<>();  
    }  
  
    @PostConstruct  
    public void init() {  
        log.info("\nUsing Library Version v{}", SerialPort.getVersion());  
        SerialPort[] ports = SerialPort.getCommPorts();  
        log.info("\nAvailable Ports:\n");  
        Map portMappings = serialPortConfig.getPortMappings();  
        for (SerialPort port : ports) {  
            log.info("{}: {} - {}", port.getSystemPortName(), port.getDescriptivePortName(), port.getPortDescription());  
            serialPorts.put(port.getSystemPortName(), port);  
            openPort(port.getSystemPortName());  
        }  
    }  
  
    public boolean addPort(String portName) {  
        SerialPort[] ports = SerialPort.getCommPorts();  
        for (SerialPort port : ports) {  
            if (port.getSystemPortName().equals(portName)) {  
                serialPorts.put(portName, port);  
                log.info("Added Port: {} - {}", port.getSystemPortName(), port.getDescriptivePortName());  
                return true;  
            }  
        }  
        log.info("Port {} not found!", portName);  
        return false;  
    }  
  
    /**  
     * 打开指定com口  
     */  
    public void openPort(String portName) {  
        SerialPort port = serialPorts.get(portName);  
        if (port == null) {  
            log.info("Port {} is not managed!", portName);  
            return;  
        }  
        if (!port.isOpen()) {  
            log.info("\nPre-setting RTS: {}", port.setRTS() ? "Success" : "Failure");  
            if (!port.openPort()) {  
                log.info("Open serial port {} error!", portName);  
                return;  
            }  
            log.info("\nOpening {}: {} - {}", port.getSystemPortName(), port.getDescriptivePortName(), port.getPortDescription());  
            port.setFlowControl(SerialPort.FLOW_CONTROL_DISABLED);  
            port.setComPortParameters(9600, 8, SerialPort.ONE_STOP_BIT, SerialPort.NO_PARITY);  
            port.setComPortTimeouts(SerialPort.TIMEOUT_READ_BLOCKING | SerialPort.TIMEOUT_WRITE_BLOCKING, 1000, 1000);  
            // 获取 Redis 键名  
            String redisKey = Optional.ofNullable(serialPortConfig.getPortMappings()).map(a -> a.get(portName)).orElse("pc:weight:unknown");  
  
            // 直接开始解析  
            SerialPortListener listener = new SerialPortListener(port, portName, redisTemplate, redisKey);  
            listeners.put(portName, listener);  
            Thread listenerThread = new Thread(listener);  
            listenerThread.start();  
        }  
    }  
  
    /**  
     * 判断指定com口是否打开  
     */  
    public boolean isPortOpen(String portName) {  
        SerialPort port = serialPorts.get(portName);  
        return port != null && port.isOpen();  
    }  
  
    /**  
     * 关闭指定com口  
     */  
    public void closePort(String portName) {  
        SerialPort port = serialPorts.get(portName);  
        SerialPortListener listener = listeners.get(portName);  
        if (port != null && port.isOpen()) {  
            if (listener != null) {  
                listener.stop();  
                listeners.remove(portName);  
            }  
            port.closePort();  
            log.info("Closed Port: {}", portName);  
        }  
    }  
  
    /**  
     * 向指定com口发送数据  
     */  
    public int write(String portName, byte[] data) {  
        SerialPort port = serialPorts.get(portName);  
        if (port == null || !port.isOpen()) {  
            return 0;  
        }  
        return port.writeBytes(data, data.length);  
    }  
  
    /**  
     * 从指定com口读取数据  
     */  
    public int read(String portName, byte[] data) {  
        SerialPort port = serialPorts.get(portName);  
        if (port == null || !port.isOpen()) {  
            return 0;  
        }  
        return port.readBytes(data, data.length);  
    }  
  
    /**  
     * 向指定com口发送数据并且读取数据  
     */  
    public byte[] writeAndRead(String portName, byte[] bytes) {  
        byte[] resultData = null;  
        try (ByteArrayOutputStream bao = new ByteArrayOutputStream()) {  
            SerialPort port = serialPorts.get(portName);  
            if (port == null || !port.isOpen()) throw new BhudyException("Port not open or not found: " + portName);  
            int numWrite = port.writeBytes(bytes, bytes.length);  
            if (numWrite > 0) {  
                Thread.sleep(100); // 休眠0.1秒，等待下位机返回数据。如果不休眠直接读取，有可能无法成功读到数据  
                while (port.bytesAvailable() > 0) {  
                    byte[] newData = new byte[port.bytesAvailable()];  
                    int numRead = port.readBytes(newData, newData.length);  
                    if (numRead > 0) {  
                        bao.write(newData);  
                    }  
                }  
                resultData = bao.toByteArray();  
            }  
        } catch (Exception e) {  
            throw new BhudyException(e.getMessage());  
        }  
        return resultData;  
    }  
  
    /**  
     * 向指定com口发送数据并且读取数据  
     */  
    public String readWeightOnce(String portName) {  
        try {  
            // 固定读取12位  
            byte[] readBuffer = new byte[12];  
            SerialPort port = serialPorts.get(portName);  
            int numRead = port.readBytes(readBuffer, readBuffer.length);  
            if (numRead > 0) {  
                String result = SerialPortUtil.parseWeightData(readBuffer);  
                log.info("{}读取只读取一次串口{}的数据为:{}", LocalDateTime.now(), portName, result);  
                return result;  
            }  
        } catch (Exception e) {  
            throw new BhudyException(e.getMessage());  
        }  
        return null;  
    }  
  
    /**  
     * 关闭所有com口  
     */  
    public void closeAllPorts() {  
        for (String portName : serialPorts.keySet()) {  
            closePort(portName);  
        }  
    }  
}

报文解析工具类

包含指令生成和报文解析方法

package cn.allbs.weightscale.util;  
  
import cn.allbs.weightscale.exception.BhudyException;  
import lombok.experimental.UtilityClass;  
import lombok.extern.slf4j.Slf4j;  
  
import java.util.Arrays;  
  
/**  
 * 类 SerialPortUtil  
 * * @author ChenQi  
 * @date 2024/6/11  
 */
 @Slf4j  
@UtilityClass  
public class SerialPortUtil {  
  
    /**  
     * 十六进制数的字符串转换为对应的字节数组  
     *  
     * @param s 十六进制字符串  
     * @return 字节数组  
     */  
    public static byte[] hexStringToByteArray(String s) {  
        s = s.replaceAll("\\s", ""); // 去除所有空格  
        int len = s.length();  
  
        // 确保字符串长度为偶数  
        if (len % 2 != 0) {  
            throw new IllegalArgumentException("Invalid hex string: " + s);  
        }  
  
        byte[] data = new byte[len / 2];  
        for (int i = 0; i < len; i += 2) {  
            int high = Character.digit(s.charAt(i), 16);  
            int low = Character.digit(s.charAt(i + 1), 16);  
            if (high == -1 || low == -1) {  
                throw new IllegalArgumentException("Invalid hex character in string: " + s);  
            }  
            data[i / 2] = (byte) ((high << 4) + low);  
        }  
        return data;  
    }  
  
  
    /**  
     * 字节数组转换为十六进制字符串  
     *  
     * @param byteArray 字节数组  
     * @return 十六进制字符串  
     */  
    public static String byteArrayToHexString(byte[] byteArray) {  
        StringBuilder hexString = new StringBuilder();  
        for (byte b : byteArray) {  
            hexString.append(String.format("%02X ", b));  
        }  
        // 去掉最后一个空格  
        return hexString.toString().trim();  
    }  
  
    /**  
     * 解析重量数据（主要是校验）  
     *  
     * @param data 数据  
     * @return 重量  
     */  
    public static String parseWeightData(byte[] data) {  
        if (data.length < 12) {  
            throw new BhudyException("串口未接收到数据或者数据长度不够，返回数据内容为" + Arrays.toString(data));  
        }  
        if (data[0] != 0x02 || data[data.length - 1] != 0x03) {  
            throw new IllegalArgumentException("Invalid data format");  
        }  
  
        byte[] payload = Arrays.copyOfRange(data, 1, data.length - 3);  
        byte xorHigh = data[data.length - 3];  
        byte xorLow = data[data.length - 2];  
        byte end = data[data.length - 1];  
  
        // 校验异或  
        byte calculatedXor = 0;  
        for (int i = 1; i < data.length - 3; i++) { // 从第2位到异或校验前一位  
            calculatedXor ^= data[i];  
        }  
  
        byte expectedXorHigh = (byte) ((calculatedXor >> 4) & 0x0F);  
        byte expectedXorLow = (byte) (calculatedXor & 0x0F);  
  
        // Convert XOR values to ASCII  
        expectedXorHigh += (byte) ((expectedXorHigh <= 9) ? 0x30 : 0x37);  
        expectedXorLow += (byte) ((expectedXorLow <= 9) ? 0x30 : 0x37);  
  
        if (expectedXorHigh != xorHigh || expectedXorLow != xorLow) {  
            log.info("校验失败，报文中高四位{},低四位{};主动校验后的高四位:{},低四位{};", xorHigh, xorLow, expectedXorHigh, expectedXorLow);  
        }  
  
        return parseWeight(payload);  
    }  
  
    /**  
     * 解析重量数据  
     *  
     * @param payload 数据  
     * @return 重量  
     */  
    private static String parseWeight(byte[] payload) {  
        if (payload.length != 8) {  
            throw new IllegalArgumentException("Invalid payload length for weight data");  
        }  
  
        char sign = (char) payload[0];  
        String weightValue = new String(Arrays.copyOfRange(payload, 1, 7)).trim();  
        int decimalPointPosition = payload[7] - '0';  
  
        // 插入小数点  
        StringBuilder weight = new StringBuilder(weightValue);  
        if (decimalPointPosition > 0 && decimalPointPosition < weight.length()) {  
            weight.insert(weight.length() - decimalPointPosition, '.');  
        }  
  
        // 转换为实际数值  
        String weightString = sign + weight.toString();  
  
        // 去掉小数位为0的部分  
        double weightNumber = Double.parseDouble(weightString);  
        if (decimalPointPosition == 0) {  
            return String.valueOf((int) weightNumber); // 如果小数位为0，返回整数  
        } else {  
            return String.valueOf(weightNumber);  
        }  
    }  
  
    /**  
     * 计算异或校验和  
     *  
     * @param data 数据  
     * @return 校验和  
     */  
    public static byte calculateXorChecksum(byte[] data) {  
        byte xor = 0;  
        for (byte b : data) {  
            xor ^= b;  
        }  
        return xor;  
    }  
  
    /**  
     * 生成指令  
     *  
     * @param address 地址  
     * @param command 指令  
     * @return 指令字节数组  
     */  
    public byte[] generateCommand(String address, char command) {  
        byte start = 0x02; // 开始符  
        byte end = 0x03; // 结束符  
  
        byte addressByte = (byte) address.charAt(0);  
        byte commandByte = (byte) command;  
  
        // 计算异或校验  
        byte xor = (byte) (addressByte ^ commandByte);  
        byte xorHigh = (byte) ((xor >> 4) & 0x0F);  
        byte xorLow = (byte) (xor & 0x0F);  
  
        // 高四位和低四位的ASCII码转换  
        xorHigh += (byte) ((xorHigh <= 9) ? 0x30 : 0x37);  
        xorLow += (byte) ((xorLow <= 9) ? 0x30 : 0x37);  
  
        // 生成字节数组  
        return new byte[]{start, addressByte, commandByte, xorHigh, xorLow, end};  
    }  
  
    public static void main(String[] args) {  
        byte[] data = {  
                0x02, // Start byte  
                0x2B, // '+'  
                0x30, 0x30, 0x31, 0x35, 0x30, 0x30, 0x30, 0x31, // '00150001'  
                0x46, // XOR checksum  
                0x03  // End byte  
        };  
  
        String result = parseWeightData(data);  
        System.out.println(result);  
    }  
}

串口监听器

考虑到串口持续输出数据，所以在串口初始化时，起一个线程专门监听串口数据并解析存储数据。为了减轻cpu压力，设置每100毫秒接收解析一次数据，实际上1秒一次也绝对够了。

package cn.allbs.weightscale.handler;  
  
import cn.allbs.weightscale.constants.CommonConstants;  
import cn.allbs.weightscale.util.SerialPortUtil;  
import com.fazecast.jSerialComm.SerialPort;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.data.redis.core.RedisTemplate;  
  
import java.time.LocalDateTime;  
import java.time.format.DateTimeFormatter;  
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
  
@Slf4j  
public class SerialPortListener implements Runnable {  
  
    private final SerialPort serialPort;  
    private final String portName;  
    private final RedisTemplate redisTemplate;  
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);  
    private final String redisKey;  
  
    public SerialPortListener(SerialPort serialPort, String portName, RedisTemplate redisTemplate, String redisKey) {  
        this.serialPort = serialPort;  
        this.portName = portName;  
        this.redisTemplate = redisTemplate;  
        this.redisKey = redisKey;  
    }  
  
    @Override  
    public void run() {  
        scheduler.scheduleAtFixedRate(this::readFromPort, 0, 100, TimeUnit.MILLISECONDS);  
    }  
  
    private void readFromPort() {  
        try {  
            if (serialPort.bytesAvailable() > 0) {  
                byte[] readBuffer = new byte[12]; // 根据实际数据长度调整缓冲区大小  
                int numRead = serialPort.readBytes(readBuffer, readBuffer.length);  
                if (numRead > 0) {  
                    String result = SerialPortUtil.parseWeightData(readBuffer);  
                    log.info("{}读取到串口{}的数据为:{}", LocalDateTime.now().format(DateTimeFormatter.ofPattern(CommonConstants.DATETIME_PATTERN)), portName, result);  
                    // 存入Redis  
                    redisTemplate.opsForValue().set(redisKey, result);  
                }  
            }  
        } catch (Exception e) {  
            log.error("Error reading from serial port", e);  
        }  
    }  
  
    // 停止监听器的方法  
    public void stop() {  
        scheduler.shutdown();  
    }  
}

其他相关说明

因为本来根据业务需求，指令应答方式的形式获取数据肯定是够了，所以一开始就偷了个懒没做连续发送方式的解析代码。但是老师傅在现场一句指令应答做不了给断送了。。。。只能使用连续发送的方式来获取数据，也就是项目中后续加了启动线程监听相关代码的原因。

接口说明

本项目目的是给其他服务提供地磅最新数据，所以加了接口供其他服务调用。接口文档路径为{ip}:{port}/dic.html,本项目默认设置端口为7878

连续发送方式

顾名思义项目启动后会一直接收串口数据，本项目中考虑到连续发送间隔时间太短，一是无意义数据较多，二是cpu负荷较大，所以额外起了线程，每100毫秒接收并解析一次，根据自己需要设置。
调整方式为修改SerialPortListener类中的scheduler.scheduleAtFixedRate(this::readFromPort, 0, 100, TimeUnit.MILLISECONDS);period即可，现在设置的时100,单位为毫秒
获取该数据有两种方式：

一种是获取缓存到redis中的pc:weight:*,这个*代表的是不同地磅缓存的数据，具体定义见application.yml的active和SerialPortConfig的getPortMappings方法获取的rediskey值
第二种是通过接口，/weight，这个接口是获取最新的一次称重数据，如果没有称重数据则返回null，参数需要传指定的串口名称，比如我当前项目两个串口分别为COM3,COM4一个进的地磅一个出的地磅

指令应答方式

根据指令获取具体数据
只能通过接口获取
接口: /scale
传的参数有

address地址，从A~Z
operationCode操作方式，A握手,B读毛重,C读皮重,D读净重
portName串口，比如当前项目的两个串口COM3,COM4,其他项目可能是COM1,COM2之类的。

项目运行效果

部署

考虑到是在windows中运行，万一主机关机啥的得弄个开机自启，所以使用的是Windows Service Wrapper 这个工具

下载地址

http://repo.jenkins-ci.org/releases/com/sun/winsw/winsw

使用方式

将下载下来的exe名称修改为jar包相同的名称

然后新增一个和jar相同名称的xml，内置内容如下：

<service>
    <id>weight-scaleid>
    <name>Weight Scale Servicename>
    <description>卡口进出地磅称重数据description>
    <executable>javaexecutable>
    <arguments>-jar "D:\weight-scale\weight-scale-0.0.1.jar"arguments>
    <logmode>nonelogmode>
    <startmode>Automaticstartmode>
    <stoptimeout>30secstoptimeout>
service>

需要注意其中的logmod我这边设置的是none,因为内置了logback，有对应的日志文件在logs中所以不需要额外的logmod。

注册jar为系统服务并启动

# 注册系统服务
./weight-scale-0.0.1.exe install
# 启动服务
./weight-scale-0.0.1.exe start
# 停止服务
./weight-scale-0.0.1.exe stop
# 注销系统服务
./weight-scale-0.0.1.exe uninstall

最后附上项目源码

如果对你有帮助，给个star哦😘
https://github.com/chenqi92/weight-scale.git

对接了一个园区的电子围网，全流程如下，其他TCP协议可以参考

2024-06-27T07:09:00.000Z

[!前言]
本项目采用spring boot框架，使用netty做网络应用程序框架。下面做全流程分析。项目源码地址:https://github.com/chenqi92/pc-electric-fence.git

报文协议

这个应该是厂商自家定义的报文协议，发过来就是一个txt，协议原文内容如下😂

一、通讯方式
  1. 串口方式: 波特率为9600bps,采用8-N-1格式
  2. 网络方式: PC端做TCP服务器，默认监听端口5000

二、数据包格式
  所有数据都以回车符为结束符，数据内容以空格分隔，所有数据都是有应答。
  
1. 应答（布撤防才会有成功和失败之说，其他的指令都回A 1）
  内容: A 结果
  结果: 0: 失败; 1: 成功 2: 执行成功
注：每条指令都需要回复A 1，并以回车键结束。
2. 心跳
  内容: H 设备编号 通讯方式 设备类型 
  设备编号: 为报警主机编号
  通讯方式: 0: 串口/网络; 2: GPRS
  设备类型: 0: 接警机; 1: 主机
  设备类型为非接警机时，设备跟PC连接建立后，立刻发送心跳包。
  心跳间隔默认为10秒。
举例：
  主机编号为0时：H 0 0 1
  主机编号为1时：H 1 0 1
3. 事件上传
  内容: E 主机编号 防区编号 事件代码 子系统号 月-日-时-分    
  主机编号: 接警机上报时，为接警机编号-通讯机编号-终端设备编号；主机上传时为用户编号。
  防区编号: 为0时，为非防区事件。

总线主机  事件代码参考如下:

      0:  防区布防事件
      1:  防区撤防事件
      2:  防区报警事件
      3:  防区报警恢复事件
      4:  设备被撬事件
      5:  设备被撬恢复事件
      6:  设备欠压事件
      7:  设备欠压恢复事件
      8:  设备连接故障事件
      9:  设备连接恢复事件
      10: 设备布防
      11: 设备撤防
      12: 设备挟持
      13: 通讯机连接故障事件
      14: 通讯机连接恢复事件
      15: 防区旁路事件
      16: 防区旁路恢复事件
2013.11.23
      17: 设备紧急事件
      18: 设备紧急恢复事件
      19: 设备火警事件
      20: 设备火警恢复事件
      21: 防区布防状态
      22: 防区撤防状态
      23: 防区未准备
      24: 防区未准备恢复
      25：留守布防
      26: 防区故障
      27:防区故障恢复
      28: 电话线故障
      29: 电话线故障恢复
      30: 电池故障
      31: 电池恢复
      32: 交流故障
      33: 交流恢复
      34: 围栏断线报警
      35：围栏短路报警
      36: 围栏电压子系统号：为围栏的电压值 （KV）  
      37：触网报警


围栏电压例子
  E 0001 1 36 50//1号主机的1号围栏 电压为5.0KV
      



  子系统号：可选字节，当主机有子系统时，带上子系统；没有时，不用带。


  E 6130-0-1 4 2 0 11-7-13-2 表示6130主机1号模块4防区在11月7号13点2分 
发生报警了

  主机编号: 接警机上报时，为接警机编号-通讯机编号-终端设备编号；
   6130-0-1  : 接警机是6130,即总线主机的系统地址, 
              通讯机编号是0: 表示通讯口1或2的设备,  通讯机编号是1: 表示键盘总线的设备, 
     终端设备编号: 当通讯机编号为0时, 终端设备编号 0-64, 其中0表示主机主板防区, 1-64表示扩展的1-64号设备
             当通讯机编程为1时,表示键盘设备, 128-160 ,128表示主键盘, 129-160表示1-31号分键盘

     4:表示防区4
     2: 表示防区报警事件  (具体请参考 总线主机  事件代码)
     0: 子系统号 固定为0
     11-7-13-2: 11月7号13点2分

 E 6130-1-128 0 11 0 11-7-13-3    表示 6130号主机的128号键盘(即主键盘)撤防操作在11月7号13点3分 


4. 主机控制
  内容: C 主机编号 防区编号 控制类型 密码
  防区编号: 为0时是设备控制，否则是防区控制
  控制类型: 0: 撤防 1: 布防 2: 旁路 3: 解除旁路 4：留守布防  5：高压布防  6：低压布防

  例如:主机编号为6130 ,  
C 6130-1-128 0 0 123456    表示 控制6130号主机的128号键盘(即主键盘)撤防
C 6130-1-128 0 1 123456    表示 控制6130号主机的128号键盘(即主键盘)布防

C 6130-0-1 0 1 123456    表示 控制6130号主机的1号设备布防
C 6130-0-1 1 1 123456    表示 控制6130号主机的1号设备防区1 布防

C 6130-0-1 0 0 123456    表示 控制6130号主机的1号设备撤防
C 6130-0-1 1 0 123456    表示 控制6130号主机的1号设备防区1 撤防


5. 输出点控制
  内容: O 主机编号 输出点类型 输出点号 控制类型 控制时间
  输出点类型: 0: 输出点 1: 灯   2: LED
  控制类型: 0:断开  1:闭合

O 6130-0-1 0 1 1 10    表示 控制6130号主机的1号设备的1号输出闭合10秒
O 6130-0-1 0 1 0 0      表示 控制6130号主机的1号设备的1号输出断开

协议接收考虑

对方给了一个现场如下配置

因为不可预知对方的主机类型，从报文来看最好的方式肯定是做一个TCP服务端来接收数据，让对方配合修改客户端的发送地址即可。

开发一个服务端

开发准备

因为服务器装的jdk1.8所有spring boot也不能选择3.0+，使用的maven作为依赖管理，pom内容如下

"1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <groupId>com.lycgroupId>
    <artifactId>pc-electric-fenceartifactId>
    <version>0.0.1version>
    <name>pc-electric-fencename>
    <description>电子围网报警数据接收description>
    <url/>
    <licenses>
        <license/>
    licenses>
    <developers>
        <developer/>
    developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    scm>
    <properties>
        <java.version>8java.version>
        <influx.version>2.24influx.version>
        <allbs-influx.version>2.0.2allbs-influx.version>
        <netty.version>4.1.111.Finalnetty.version>
        <spring-boot.version>2.7.18spring-boot.version>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
        <maven.compiler.version>3.8.1maven.compiler.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starterartifactId>
        dependency>

        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-configuration-processorartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>cn.allbsgroupId>
            <artifactId>allbs-influxartifactId>
            <version>${allbs-influx.version}version>
        dependency>
        <dependency>
            <groupId>org.influxdbgroupId>
            <artifactId>influxdb-javaartifactId>
            <version>${influx.version}version>
        dependency>
        <dependency>
            <groupId>io.nettygroupId>
            <artifactId>netty-allartifactId>
            <version>${netty.version}version>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-coreartifactId>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-annotationsartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jsonartifactId>
        dependency>
    dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-starter-parentartifactId>
                <version>${spring-boot.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

    <profiles>
        <profile>
            <id>devid>
            <properties>
                
                <profiles.active>devprofiles.active>
            properties>
            <activation>
                
                <activeByDefault>trueactiveByDefault>
            activation>
        profile>
        <profile>
            <id>prodid>
            <properties>
                <profiles.active>prodprofiles.active>
            properties>
        profile>
    profiles>

    <build>
        <finalName>${project.name}-${project.version}finalName>
        <resources>
            <resource>
                <directory>src/main/resourcesdirectory>
                <filtering>truefiltering>
                <includes>
                    <include>**/*include>
                includes>
            resource>
        resources>
        <pluginManagement>
            <plugins>
                
                <plugin>
                    <groupId>org.springframework.bootgroupId>
                    <artifactId>spring-boot-maven-pluginartifactId>
                    <version>${spring-boot.version}version>
                    <configuration>
                        <executable>trueexecutable>
                    configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackagegoal>
                            goals>
                        execution>
                    executions>
                plugin>
            plugins>
        pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombokgroupId>
                            <artifactId>lombokartifactId>
                        exclude>
                    excludes>
                configuration>
            plugin>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>${maven.compiler.version}version>
                <configuration>
                    <target>${maven.compiler.target}target>
                    <source>${maven.compiler.source}source>
                    <encoding>UTF-8encoding>
                    <skip>trueskip>
                configuration>
            plugin>
        plugins>
    build>

project>

其中allbs-influx这个包是我自己封装的处理influxDb存和取操作的，如果没有需要可以去除，包括下面的influxdb-java

项目结构如下

pc-electric-fence
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── lyc
│   │   │           └── pcelectricfence
│   │   │               ├── constant
│   │   │               │   └── CommonConstant.java
│   │   │               ├── enums
│   │   │               │   ├── CommunicationMode.java
│   │   │               │   ├── ControlType.java
│   │   │               │   ├── DeviceEnum.java
│   │   │               │   ├── DeviceType.java
│   │   │               │   ├── EventType.java
│   │   │               │   ├── OutputControlType.java
│   │   │               │   ├── OutputPointType.java
│   │   │               │   └── ResponseType.java
│   │   │               ├── netty
│   │   │               │   ├── NettyServer.java
│   │   │               │   ├── NettyServerHandlerInitializer.java
│   │   │               │   └── ProtocolHandler.java
│   │   │               ├── properties
│   │   │               │   └── NettyServerProperties.java
│   │   │               ├── utils
│   │   │               │   └── CommandParserUtil.java
│   │   │               └── PcElectricFenceApplication.java
│   │   └── resources
│   │       ├── application-dev.yml
│   │       ├── application-prod.yml
│   │       ├── application.yml
│   │       └── logback-spring.xml
│   └── test
│       └── java
│           └── com
│               └── lyc
│                   └── pcelectricfence
│                       └── PcElectricFenceApplicationTests.java
├── README.md
├── pom.xml
└── 协议.md

文件内容一览

CommonConstant

一个常量定义，只有influxdb需要储存的表名和日期格式化

public interface CommonConstant {

    /**
     * 电子围栏数据表
     */
    String INFLUXDB_DATABASE_MEASUREMENT = "cl_electronic_patrol_alarm";

    /**
     * 时间格式
     */
    String NORM_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 报警信息中的时间格式
     */
    String ALARM_DATETIME_PATTERN = "yyyy年MM月dd日HH时mm分";
}

所有的枚举

这个没有什么好说的就是根据报文协议抽出来的东西,下面就不列了，有需要的可以到文末的源码上去看

NettyServer

主要是用来启动项目时启动server监听指定端口，还有就是编码器和解码器加上接收数据处理的handler，详细代码为如下，基本每行都有注解，就不一一阐述了。

package com.lyc.pcelectricfence.netty;

import com.lyc.pcelectricfence.properties.NettyServerProperties;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.ReadTimeoutHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import java.net.InetSocketAddress;
import java.util.concurrent.TimeUnit;

/**
 * 类 NettyServer
 *
 * @author ChenQi
 * @date 2024/6/20
 */
@Slf4j
@Component
public class NettyServer {

    @Resource
    private NettyServerProperties nettyServerProperties;

    /**
     * 心跳超时时间
     */
    private static final Integer READ_TIMEOUT_SECONDS = 3 * 60;

    /**
     * boss 线程组，用于服务端接受客户端的连接
     */
    private final EventLoopGroup bossGroup = new NioEventLoopGroup();
    /**
     * worker 线程组，用于服务端接受客户端的数据读写
     */
    private final EventLoopGroup workerGroup = new NioEventLoopGroup();

    @Resource
    private ProtocolHandler protocolHandler;

    /**
     * Netty Server Channel
     */
    private Channel channel;

    /**
     * 启动 Netty Server
     */
    @PostConstruct
    public void start() throws InterruptedException {
        // 创建 ServerBootstrap 对象，用于 Netty Server 启动
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        // 作为分隔符的数据包,防止粘包，虽然报文说是回车分隔，实际上没有，所以未使用,下面的代码注释掉同理
//        ByteBuf delimiter = Unpooled.copiedBuffer("\r\n".getBytes());
        serverBootstrap.group(bossGroup, workerGroup)
                // 指定 Channel 为服务端 NioServerSocketChannel
                .channel(NioServerSocketChannel.class)
                // 端口
                .localAddress(new InetSocketAddress(nettyServerProperties.getPort()))
                // 服务端接收队列的大小
                .option(ChannelOption.SO_BACKLOG, 1024)
                // TCP Keepalive 机制，实现 TCP 层级的心跳保活功能
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                // 允许较小的数据包的发送，降低延迟
                .childOption(ChannelOption.TCP_NODELAY, true)
                .childHandler(new ChannelInitializer() {
                    @Override
                    protected void initChannel(SocketChannel ch) {
                        // 空闲检测
                        ch.pipeline().addLast(new ReadTimeoutHandler(READ_TIMEOUT_SECONDS, TimeUnit.SECONDS));
//                        ch.pipeline().addLast(new DelimiterBasedFrameDecoder(16 * 1024, false, delimiter));
                        // 解码器，因为客户端发送的是字符串所以直接用String即可，如果是其他的需要对应的解码
                        ch.pipeline().addLast(new StringDecoder());
                        // 跟编码器同理
                        ch.pipeline().addLast(new StringEncoder());
                        // 添加连接事件处理
                        ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                            @Override
                            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                log.info("{}远程客户端连接！", ctx.channel().remoteAddress());
                                super.channelActive(ctx);
                            }
                        });
                        // 处理收到报文的方法
                        ch.pipeline().addLast(protocolHandler);
                    }
                });

        // 绑定端口，并同步等待成功，即启动服务端
        ChannelFuture future = serverBootstrap.bind().sync();
        if (future.isSuccess()) {
            channel = future.channel();
            log.info("netty服务端已启动,启动端口为{}", nettyServerProperties.getPort());
        }
    }

    @PreDestroy
    public void stop() {
        log.info("{} 服务主动断开连接!", channel.localAddress());
        // 关闭 Netty Server
        if (channel != null) {
            channel.close();
        }
        // 优雅关闭两个 EventLoopGroup 对象
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

最后是处理的handler

这个类中包含的东西不多，只是集成SimpleChannelInboundHandler并重写channelRead0，exceptionCaught。一个是用来处理报文的方法，一个是用来监听异常的方法，其他代码都是根据报文内容定制。

唯一需要注意的就是注解@ChannelHandler.Sharable这个注解的作用是标识一个 ChannelHandler 实例可以在多个ChannelPipeline 中共享使用。通常，ChannelHandler 实例是不可共享的，因为它们在处理不同的连接时可能会维护一些特定于连接的状态信息。而 @ChannelHandler.Sharable 的存在则表示这个 ChannelHandler 实例是无状态的，或者其状态对于多个连接是安全的，可以共享使用。简单点说就是为了让你这个服务端能够被多个客户端连上。

package com.lyc.pcelectricfence.netty;

import cn.allbs.influx.InfluxTemplate;
import com.lyc.pcelectricfence.enums.CommunicationMode;
import com.lyc.pcelectricfence.enums.DeviceType;
import com.lyc.pcelectricfence.enums.ResponseType;
import com.lyc.pcelectricfence.utils.CommandParserUtil;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.ReadTimeoutException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

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

import static com.lyc.pcelectricfence.constant.CommonConstant.INFLUXDB_DATABASE_MEASUREMENT;

/**
 * 类 ProtocolHandler
 *
 * @author ChenQi
 * @date 2024/6/20
 */
@Slf4j
@Component
@ChannelHandler.Sharable
public class ProtocolHandler extends SimpleChannelInboundHandler {

    @Resource
    private InfluxTemplate influxTemplate;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        log.info("Received message: {}", msg);
        String[] parts = msg.trim().split(" ");
        switch (parts[0]) {
            case "A":
                handleResponse(ctx, parts);
                break;
            case "H":
                handleHeartbeat(ctx, parts);
                break;
            case "E":
                handleEventUpload(ctx, parts);
                break;
            case "C":
                handleControl(ctx, parts);
                break;
            case "O":
                handleOutputControl(ctx, parts);
                break;
            default:
                // Handle unknown command
                break;
        }
        // 发送回复消息
        ctx.writeAndFlush("A 1\r\n");
    }

    /**
     * 处理响应
     *
     * @param ctx   ChannelHandlerContext
     * @param parts 消息分割后的数组
     */
    private void handleResponse(ChannelHandlerContext ctx, String[] parts) {
        int result = Integer.parseInt(parts[1]);
        ResponseType responseType = ResponseType.values()[result];
        log.debug("Response: {}", responseType.getDescription());
    }

    /**
     * 处理心跳
     *
     * @param ctx   ChannelHandlerContext
     * @param parts 消息分割后的数组
     */
    private void handleHeartbeat(ChannelHandlerContext ctx, String[] parts) {
        int deviceNumber = Integer.parseInt(parts[1]);
        CommunicationMode communicationMode = CommunicationMode.values()[Integer.parseInt(parts[2])];
        DeviceType deviceType = DeviceType.values()[Integer.parseInt(parts[3])];
        log.debug("Heartbeat - Device Number: {}, Communication Mode: {}, Device Type: {}", deviceNumber, communicationMode.getDescription(), deviceType.getDescription());
    }

    /**
     * 处理事件上传
     *
     * @param ctx   ChannelHandlerContext
     * @param parts 消息分割后的数组
     */
    private void handleEventUpload(ChannelHandlerContext ctx, String[] parts) {
        // 事件上传，储存至influxDb
        String command = String.join(" ", parts);
        Map map = CommandParserUtil.parseEventUploadCommand(command);
        log.debug("Event Upload Command: {}", map);
        Map tags = new HashMap<>();
        tags.put("type", "E");
        tags.put("typeName", "事件上传");
        // 储存至influxDb
        influxTemplate.insert(INFLUXDB_DATABASE_MEASUREMENT, tags, map);
    }

    /**
     * 处理控制
     *
     * @param ctx   ChannelHandlerContext
     * @param parts 消息分割后的数组
     */
    private void handleControl(ChannelHandlerContext ctx, String[] parts) {
        // 处理控制 TODO
        String command = String.join(" ", parts);
        Map map = CommandParserUtil.parseHostControlCommand(command);
        log.debug("Control Command: {}", map);
        Map tags = new HashMap<>();
        tags.put("type", "C");
        tags.put("typeName", "主机控制");
        // 储存至influxDb
        influxTemplate.insert(INFLUXDB_DATABASE_MEASUREMENT, tags, map);
    }

    /**
     * 处理输出控制
     *
     * @param ctx   ChannelHandlerContext
     * @param parts 消息分割后的数组
     */
    private void handleOutputControl(ChannelHandlerContext ctx, String[] parts) {
        // 输出控制
        String command = String.join(" ", parts);
        Map map = CommandParserUtil.parseOutputControlCommand(command);
        log.debug("Output Control Command: {}", map);
        // 储存至influxDb
        Map tags = new HashMap<>();
        tags.put("type", "O");
        tags.put("typeName", "输出点控制");
        influxTemplate.insert(INFLUXDB_DATABASE_MEASUREMENT, tags, map);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        if (cause instanceof ReadTimeoutException) {
            log.info("Read timeout occurred. {}", ctx.channel());
        } else {
            log.info(cause.getLocalizedMessage());
        }
        ctx.close();
    }
}

最后需要注意的问题

因为这个项目中并未使用spring-boot-start-web，也就是没有tomcat或者undertow等web框架，所以实际server.port本来设置的6767并未使用，后来我一想，不如直接当作netty server的监听地址吧，所以NettyServerProperties直接使用了本来配给netty server的5000端口作为监听端口，所以你会看到项目的md中有6767这个端口但又未实际使用。如果你的项目有web框架，肯定不能这么干，需要将netty sever重新配置一个另外的端口。

删除git提交日志

2024-06-27T06:25:00.000Z

背景

开发了一个报文解析程序，并且同时往github和公司的库中传，这样可以刷些github的活跃，也能给有需要的人参考。但是一不小心将测试和正式环境的数据库连接传进去了，这可是大大的不行，所以需要在日志中删除这些记录，同时保留其他修改。PS:还是不能懒啊，配置文件中敏感信息最好还是用系统变量😑

使用安装 `git filter-repo` 工具

1	pip3 install git-filter-repo

git配置文件修改确保能够使用该python

修改的配置内容

1 2	[alias] filter-repo = !python -m git_filter_repo

git配置文件

修改示例

删除历史记录中的敏感文件

注意执行命令的位置为项目工程内
比如我想删除的是application-dev.yml和applicatin-prod.yml两个文件，这两个文件所在目录为我执行目录下的src/main/resources目录下，所以最后的命令为

1	python -m git_filter_repo --path src/main/resources/application-dev.yml --path src/main/resources/application-prod.yml --invert-paths --force

强制推送清理后的历史记录到远程仓库

1	git push origin --force --all

注意看下图我使用的github为分支名，我需要清洗的是往github库中记录，我这个分支命名为github，所以使用的不是origin, 如果你们要使用需要根据你们实际情况修改。

DNF私服

2024-06-24T01:23:00.000Z

效果

注册

windows启动一个centerOS服务器作为服务端，有现成服务器的忽略这一步。

CenterOS下载地址

https://app.vagrantup.com/centos/boxes/7

windows中启动一个CenterOS虚拟机

虚拟机有线连接并`ifconfig`查看ip

前置操作（使用CenterOS服务器）

先升级yum源

1	yum update -y

下载docker安装脚本

1	curl -fsSL https://get.docker.com -o get-docker.sh

运行安装docker的脚本

1	sudo sh get-docker.sh

启动docker

1 2	systemctl enable docker systemctl restart docker

关闭防火墙

1 2	systemctl disable firewalld systemctl stop firewalld

关闭selinux

1	sudo sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/selinux/config

创建swap(如果内存足够可以直接忽略)

/bin/dd if=/dev/zero of=/var/swap.1 bs=1M count=8000
mkswap /var/swap.1
swapon /var/swap.1
sed -i '$a /var/swap.1 swap swap default 0 0' /etc/fstab

查看操作系统是否打开swap的使用(如果内存足够可以直接忽略)

sudo vim /etc/sysctl.conf 

# 将vm.swappiness的值修改为100(优先使用swap),没有该配置就加上
vm.swappiness = 100

最后执行以下命令使配置生效：

sysctl -p

部署服务

拉取镜像(根据你的CenterOS版本拉取对应镜像)

docker pull 1995chen/dnf:centos5-2.1.4.fix1
docker pull 1995chen/dnf:centos6-2.1.4.fix1
# 如何您需要使用centos7作为基础镜像的特殊需求,可以使用:
docker pull 1995chen/dnf:centos7-2.1.4.fix1
# 国内镜像无法拉取请使用[完整复制整行命令执行]
docker pull registry.cn-hangzhou.aliyuncs.com/1995chen/dnf:centos7-2.1.4.fix1 && docker tag registry.cn-hangzhou.aliyuncs.com/1995chen/dnf:centos7-2.1.4.fix1 1995chen/dnf:centos7-2.1.4.fix1
# 所有镜像版本列表请参考[记得点赞三连,帮助更多的人了解该镜像]:
https://hub.docker.com/repository/docker/1995chen/dnf

开始拉取

拉取成功

启动服务(里面的参数必须要修改！！！注意启动参数里面的centeros版本)

注意最后的centeros7、6、5要和上面拉取的镜像对应！

# 创建一个目录,这里以/data为例,后续会将该目录下的mysql以及data目录挂载到容器内部
mkdir -p /data/log /data/mysql /data/data
# 2.1.0版本镜像启动时会自动初始化mysql数据
# 启动服务
# PUBLIC_IP为公网IP地址，如果在局域网部署则用局域网IP地址，按实际需要替换
# GM_ACCOUNT为登录器用户名，建议替换
# GM_PASSWORD为登录器密码，建议替换
# DNF_DB_ROOT_PASSWORD为mysql root密码,容器启动是root密码会跟随该环境变量的变化自动更新
# WEB_USER为supervisor web管理页面用户名
# WEB_PASS为supervisor web管理页面密码(可以访问PUBLIC_IP:2000来访问进程管理页面)
# --shm-size=8g【不可删除】，docker默认为64M较小，需要增加才能保证运行
docker run -d -e PUBLIC_IP=x.x.x.x -e WEB_USER=root -e WEB_PASS=123456 -e DNF_DB_ROOT_PASSWORD=88888888 -e GM_ACCOUNT=gmuser -e GM_PASSWORD=gmpass -v /data/log:/home/neople/game/log -v /data/mysql:/var/lib/mysql -v /data/data:/data -p 2000:180 -p 3000:3306/tcp -p 7600:7600/tcp -p 881:881/tcp -p 7001:7001/tcp -p 7001:7001/udp -p 10011:10011/tcp -p 11011:11011/udp -p 10052:10052/tcp -p 11052:11052/udp -p 7200:7200/tcp -p 7200:7200/udp -p 2311-2313:2311-2313/udp --cap-add=NET_ADMIN --hostname=dnf --cpus=1 --memory=1g --memory-swap=-1 --shm-size=8g --name=dnf 1995chen/dnf:centos7-2.1.4.fix1

有时候可能启动不成功

可以restart一下

或者用docker-compose

services:

  dnf:
    hostname: dnf
    image: 1995chen/dnf:centos5-2.1.4.fix1
    # privileged: true
    cap_add:
      - NET_ADMIN
    environment:
      - TZ=Asia/Shanghai
      # 数据库root密码
      - DNF_DB_ROOT_PASSWORD=88888888
      - GM_ACCOUNT=gmuser
      - GM_PASSWORD=gmpass
      - GM_CONNECT_KEY=763WXRBW3PFTC3IXPFWH
      - GM_LANDER_VERSION=20180307
      # 手动指定对外IP
      - PUBLIC_IP=127.0.0.1
      # Netbird[可选配置][没有公网IP的可选私有内网接入]
      #- NB_SETUP_KEY=''
      #- NB_MANAGEMENT_URL=''
      # 开启DDNS[可选配置]
      # - DDNS_ENABLE=true
      # - DDNS_DOMAIN=''
    # shm_size: 8g【不可删除】，docker默认为64M较小，需要增加才能保证运行
    shm_size: 8g
    memswap_limit: -1
    mem_limit: 1g
    cpu_count: 1
    restart: always
    ports:
      - 2000:180/tcp              # supervisor web
      - 3000:3306/tcp             # mysql
      - 7600:7600/tcp             # 统一登陆器
      - 881:881/tcp               # 统一网关
      - 7001:7001/tcp             # df_channel_r
      - 7001:7001/udp             # df_channel_r
      - 7200:7200/tcp             # df_relay_r
      - 7200:7200/udp             # df_relay_r
      - 10011:10011/tcp           # df_game_r[ch.11]
      - 11011:11011/udp           # df_game_r[ch.11]
      - 10052:10052/tcp           # df_game_r[ch.52]
      - 11052:11052/udp           # df_game_r[ch.52]
      - 2311-2313:2311-2313/udp   # df_stun_r
    volumes:
      - ./data:/data
      - ./mysql:/var/lib/mysql
      - ./log:/home/neople/game/log

等待几分钟启动

访问你部署的ip:2000查看进程管理页面,出现如下页面说明你的程序启动成功了

如果是云服务器需要开放对应端口

添加本地host

下载客户端、网关和补丁

链接：https://pan.baidu.com/s/1OXWplfbkSXv3IyLFJhVtVA
提取码：6666

生成登陆器

配置网关

运行

下面红色字体就是上面docker执行运行命令中配置的内容，通信密钥固定为763WXRBW3PFTC3IXPFWH

生成登陆器

里面的ip是你虚拟器服务端的ip地址,注意游戏版本必须和网关中的一致

将登录器拷贝到游戏的目录下

双击登陆器运行

Apple小火箭跳过开屏广告

2024-06-23T05:23:00.000Z

说明

之前发过一篇文章说明Apple跳过广告的方法，主要是讲了surge，小火箭一笔带过。结果下面很多人反馈规则不生效，所以今天我就使用小火箭来试一下并说明使用方法。

首先我要说的是，之前分享的规则并不是所有app都能生效！因为作者写的规则肯定不会覆盖到所有app的，如果需要不存在里面的需要自己去单独找或者自己写。我这边是建议用圈X，相对而言用的人较多，规则也较全。

使用方式

首先打开https解密

我是一开始就使用了https解密，并没有试验过是不是一定要https解密。实际上当我关闭https解密时跳过广告也能生效，但是留言有小伙伴提醒需要，那我就加上https解密的配置，作为保险手段。
打开方式：
配置->右上角+号，导入下列url
https://whatshub.top/config/shadowrocket_basic.conf

导入完成后，点击新增的本地配置shadowrocket_basic.conf点击使用配置按钮。

点击配置文件https解密按钮。

打开https解密按钮

安装证书

在iphone中的设置->通用->VPN与设备管理中安装证书

配置文件->模块->导入

通过url添加模块规则

url链接为:

https://whatshub.top/module/adultraplus.module

等到一会添加完成之后会有弹框提示，然后确保出现如下界面，APP启动页去广告ultra+旁边勾上。

启用规则

注意下方的全局路由选择配置,然后上方小火箭那开关要打开。

使用效果，以知乎app为例

苹果手机跳过APP开屏广告的办法

2024-06-23T04:23:00.000Z

[!前言]
是不是被各APP开屏广告搞的厌烦？羡慕安卓有李跳跳这种方便的工具？下面我将告诉你如何在苹果手机中屏蔽这些烦人的广告。

需要借助的软件

圈x、surge、小火箭等都可以。这三款软件截图如下:

注意：下载这些软件的前提都是需要一个苹果的外区账号，美区、港区等都可以，我这边建议用美区的。可以在官网注册，注册时地区选择非大陆的其他地区，不用绑定支付方式。但是下载这些软件有的是需要付费或者内购的，可以使用苹果礼品卡充值。充值方式看这篇：

软件的用法

无论哪款软件都需要的前提

需要将mitm开关或https解密打开！！！

surge

surge需要内购，几十美刀还挺贵，贵在功能晚上界面做的也不错，下面这个网址是surge的各种模块链接，目的都是拓展苹果中app的功能，点击需要的模块粘贴到surge的模块中即可使用。当前只说跳过APP开屏广告，其他功能感兴趣的可以自己看看。

https://whatshub.top/surge

如果只需要跳过广告的功能只需要这个链接
https://whatshub.top/module/adultraplus.sgmodule

具体怎么使用，请看VCR:

开启后的效果如下:

圈X

圈x是一个性价比比较高的方案，用的人也挺多的。圈x只有下载的8美刀，换算rmb50多块吧。
因为我没买圈X，只能提供一个详细的用法链接给你们，github作者禁止转载，你们可以具体看这个链接中的内容:
https://github.com/ddgksf2013

模块链接可以使用:
https://whatshub.top/quantumultx

其他用法感兴趣的可以自己添加，比如没有vip依旧解锁vip功能等。去开屏广告使用如下模块链接:
https://whatshub.top/rewrite/adultraplus.conf

小火箭

具体的操作可以查看这篇文章

📄 小火箭的操作文档

模块链接：

https://whatshub.top/shadowrocket

去开屏广告的话直接复制这个模块链接:

https://whatshub.top/module/adultraplus.module

异地组网-----tailscale

2024-06-19T06:40:00.000Z

[!前言]
日常生活中肯定遇到这种情况：在家里的时候需要访问公司网络，或者两个不同的家庭玩一款不具备游戏服务器的单机游戏。但是两个网络环境都为局域网，肯定没法互相访问。那么针对这种情况，除了使用ddns代理公网ip并配置微信公众号说了秒删的那种方式外还可以使用tailscale做异地组网。异地组网是将两个不同的局域网连接起来，所以配置环境肯定是需要两个以上，下面是针对一个端为istoreos的软路由系统,另外一个端为windows系统的情况的示例，可以类比到两个端都为windows、两个端都为linux、一个端IOS一个端windows等情况。我就不一一列举了，至于安装方式都是大同小异的。

windows系统(其中一个局域网)

下载windows中的tailscale

https://tailscale.com/download/windows

设置windows中internet属性

在cmd中输入inetcpl.cpl打开并勾上全部

启动Ip Helper

安装

在控制栏中打开tailscale

登录后控制面板中就可以看到组网的两台机器

软路由istoreOS系统(另外一个局域网，如果还是windows将上述过程重复一遍即可)

在系统商店里面搜索后点击安装

打开tailscale官网

https://tailscale.com/

注册登录

我这里用的是谷歌登录，没有科学的可以用其他登录方式

在软路由中打开tailscale

获取tailscale的登录连接

通过shell登录到istoreos中并输入指令tailscale up获取登录链接

将链接复制到浏览器中

用你注册时的方式登录即可

这样你的设备就注册进去啦

查看istoreOS中的状态

显示以下内容说明成功了

测试使用

使用tailscale控制面板中的ip进行登录，发现已经能够正常访问异地组网的机器，注意这边用的ip是tailscale中的地址而不是你内网设备的ip地址。

智能家居-----协议篇

2024-06-13T02:25:00.000Z

[!前言]
智能家居不同厂家设备协议是五花八门，现阶段常用的是蓝牙(小米)，Zigbee(绿米)，wifi(各式各样厂家app)，Matter(Google、Apple、Amazon等)

1. Wi-Fi

优点:

广泛兼容: 几乎所有智能设备和家用路由器都支持Wi-Fi。
高带宽: 适合需要大量数据传输的设备，如摄像头、智能电视等。
覆盖范围广: 家庭中的大部分区域都能覆盖。
缺点:
功耗高: 对于电池供电的设备不太友好。
网络拥堵: 设备过多时，可能导致网络拥堵，影响设备响应速度。

2. Zigbee

绿米家的，很方便的能够接入apple的家庭。
优点:

低功耗: 适合电池供电的设备，如传感器、智能门锁等。
自组网: 设备可以自动组建和维护网络，网络稳定性高。
支持设备多: 一个Zigbee网络可以支持上百个设备。
缺点:
需要网关: 大多数情况下，需要一个Zigbee网关连接到家庭网络。
带宽较低: 不适合大量数据传输的设备。

3. Z-Wave

优点:

低功耗: 类似Zigbee，适合电池供电的设备。
设备互通性强: 通过Z-Wave联盟认证的设备能互通。
网络稳定: 自组网功能使得网络稳定性高。
缺点:
需要网关: 与Zigbee类似，需要一个Z-Wave网关。
设备选择相对少: 相较于Zigbee和Wi-Fi，支持Z-Wave的设备种类较少。

4. Bluetooth Low Energy (BLE)

米家就是用的这个。
优点:

超低功耗: 非常适合需要长时间运行的电池供电设备。
低延迟: 适用于需要快速响应的设备，如门锁、灯泡等。
直接连接: 大多数智能手机和平板电脑都支持BLE，方便设备直接连接控制。
缺点:
覆盖范围小: 通常在10-50米左右，不适合大面积家庭。
设备数量限制: 一个BLE网络能支持的设备数量有限。

5. Thread

优点:

低功耗: 适合电池供电的设备。
自组网: 类似Zigbee和Z-Wave，具有自组网和自修复功能。
无单点故障: 没有单一的网关，网络更可靠。
缺点:
需要网关: 虽然本身不需要单一网关，但要与互联网通信，还是需要一个网关设备。
设备相对少: 目前支持Thread协议的设备还不多。

6. Matter

绿米设备已经在逐渐支持
优点:

兼容性强: 旨在解决智能家居设备之间的互操作性问题，跨品牌和协议兼容。
统一标准: 由多个主要科技公司支持（如Google、Apple、Amazon），未来前景广阔。
缺点:
新兴协议: 尚处于推广阶段，设备选择相对较少。
需要软件更新: 现有设备可能需要固件升级才能支持Matter协议。

7. Infrared (IR) and Radio Frequency (RF)

优点:

广泛应用: 传统的家电设备，如电视、空调等常用。
不依赖网络: 可以在无网络情况下工作。
缺点:
无反馈: 无法确认设备是否收到并执行指令。
视线限制: 红外线需要直接视线，受障碍物影响。

8. KNX

优点:

稳定可靠: 广泛用于楼宇自动化，具有很高的可靠性和稳定性。
灵活扩展: 可以轻松扩展，适用于大型住宅和商业建筑。
缺点:
安装复杂: 需要专业安装和编程，不适合普通家庭用户。
成本高: 初期安装和维护成本较高。

智能家居-----智能开关和灯具篇

2024-06-13T01:25:00.000Z

要实现自动开关灯有几种组合

凌动开关+智能灯: 传统家庭灯具得开关无论几开实际上控制得是一条火线，并没有零线。凌动开关就是一个普通开关加一个弹簧，实现按开开关后自动回弹，保持灯具通路状态，直接在智能灯上实现亮/灭。
智能开关(单火线版)+普通灯: 同样是没有零线得家庭得一种选择，智能开关无需零线。但是单火是无法完全断开电路的，开关断开后依然会有微弱电流，这个时候如果遇到功率比较低或者启动器质量差的灯具，就会导致灯具有微弱亮光，或者间歇闪烁。同样电压不稳定也会对智能开关自身造成影响，我们知道智能开关最后肯定是需要接入网关或者app中，那么这就会导致智能开关频繁的在线和离线。
智能开关(零火线通断开关)+普通灯:智能开关接入稳定，但是需要装修时预留零线，其实也可以后期从灯具的位置引一根零线到插座中，就是麻烦一点。注意这种开关一般也会分两种，一种是必须接入网关的版本，一种是直接接入app的版本。网关版本需要你额外加一个本地化的网关，才能将开关接入进去，但是这种方式哪怕你家断网也可以执行一些本地化的操作。直接接入app，优点是不用再加一个需要一直通电的网关，所有执行的请求会从云端过一次，导致一是执行速度慢，而是容易被断网所影响。
智能开关(零火线智能面板)+普通灯:同样接入比较稳定，同样需要预留零线。智能面板一般也是会预留三个有线控制，也就是说这些开关可以直接控制灯具。智能面板的会有自定义的面版组合，你可以在里面加入若干的无线开关、加入窗帘开关等等，这种面板不局限开关数据和分布，理论上有无限种可能。而且有的面板自带网关，可以将其他需要接入网关的设备接入其中。
智能开关+智能灯:唯一有变化的就是普通灯变为智能灯，智能灯说实话优点鸡肋，无非是更换颜色和日/夜模式，而且智能灯的款式远远不如普通灯多。说实话，调亮度有些用但是基本上没啥大用。
以表格展示:

组合形式	前置条件	优点	缺点
凌动开关+智能灯	无需零线	无需零线	凌动开关选择面太少，长的还丑，又厚实，开关声音还贼大，开关时间还有要求，短了不行。智能灯款式少。
智能开关(单火线版)+普通灯	无需零线	无需零线	无法完全断开电路，可能导致微弱亮光或间歇闪烁。开关可能会频繁在线和离线。普通灯款式多。
智能开关(零火线通断开关)+普通灯	需要零线	接入稳定，相当于凌动开关好看的多。	部分需要本地化的网关提供接入，另一部分经过云端，执行速度慢，而且家庭网络有问题时会产生联动问题。普通灯款式多。
智能开关(零火线智能面板)+普通灯	需要零线	好看，接入稳定，理论有无限种开关组合，可以接入其他智能设备。	带网关版的很贵。耗电。
智能开关+智能灯	需要零线	可以调亮度，可以切换日/夜模式。	智能灯款式较少，贵，耗电。

使用cloudflare配置一个国内镜像库，实现无科学使用docker

2024-06-07T09:15:00.000Z

背景

常使用docker的应该都知道，两年前因为那个不可说的原因，docker被墙了。但是国内还有各大厂商、高校的国内镜像，能够满足我们的日常需求。

但是，今年6月份，各大高校厂商全部关闭了docker的国内镜像库。没有docker，日常开发部署的便利性极大的降低，各种开源软件的部署变得极为麻烦。毕竟熟悉了docker之后谁愿意再去使用传统的部署方式呢。

自己部署一个docker的镜像

总所周知赛博菩萨cloudflare提供了相当多的免费功能，日常很出名的免费防ddos攻击只是他其中一个用途。今天我们就使用它提供的Workers和Pages来制作一个国内可访问的docker镜像。

开源库

https://github.com/cmliu/CF-Workers-docker.io

创建

随便取个名字进行部署操作

编辑代码

复制仓库https://github.com/cmliu/CF-Workers-docker.io的_worker.js 内容填入

内容如下(注意修改workers_url)：

// _worker.js

// Docker镜像仓库主机地址
let hub_host = 'registry-1.docker.io'
// Docker认证服务器地址
const auth_url = 'https://auth.docker.io'
// 自定义的工作服务器地址
let workers_url = 'https://你的域名'

let 屏蔽爬虫UA = ['netcraft'];

// 根据主机名选择对应的上游地址
function routeByHosts(host) {
// 定义路由表
const routes = {
// 生产环境
"quay": "quay.io",
"gcr": "gcr.io",
"k8s-gcr": "k8s.gcr.io",
"k8s": "registry.k8s.io",
"ghcr": "ghcr.io",
"cloudsmith": "docker.cloudsmith.io",

// 测试环境
"test": "registry-1.docker.io",
};

if (host in routes) return [ routes[host], false ];
else return [ hub_host, true ];
}

/** @type {RequestInit} */
const PREFLIGHT_INIT = {
// 预检请求配置
headers: new Headers({
'access-control-allow-origin': '*', // 允许所有来源
'access-control-allow-methods': 'GET,POST,PUT,PATCH,TRACE,DELETE,HEAD,OPTIONS', // 允许的HTTP方法
'access-control-max-age': '1728000', // 预检请求的缓存时间
}),
}

/**
 * 构造响应
 * @param {any} body 响应体
 * @param {number} status 响应状态码
 * @param {Object} headers 响应头
 */
function makeRes(body, status = 200, headers = {}) {
headers['access-control-allow-origin'] = '*' // 允许所有来源
return new Response(body, { status, headers }) // 返回新构造的响应
}

/**
 * 构造新的URL对象
 * @param {string} urlStr URL字符串
 */
function newUrl(urlStr) {
try {
return new URL(urlStr) // 尝试构造新的URL对象
} catch (err) {
return null // 构造失败返回null
}
}

function isUUID(uuid) {
// 定义一个正则表达式来匹配 UUID 格式
const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

// 使用正则表达式测试 UUID 字符串
return uuidRegex.test(uuid);
}

async function nginx() {
const text = `



Welcome to nginx!



Welcome to nginx!
If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.

For online documentation and support please refer to
nginx.org.

Commercial support is available at
nginx.com.

Thank you for using nginx.


`
return text ;
}

export default {
async fetch(request, env, ctx) {
const getReqHeader = (key) => request.headers.get(key); // 获取请求头

let url = new URL(request.url); // 解析请求URL
const userAgentHeader = request.headers.get('User-Agent');
const userAgent = userAgentHeader ? userAgentHeader.toLowerCase() : "null";
if (env.UA) 屏蔽爬虫UA = 屏蔽爬虫UA.concat(await ADD(env.UA));
workers_url = `https://${url.hostname}`;
const pathname = url.pathname;
const hostname = url.searchParams.get('hubhost') || url.hostname; 
const hostTop = hostname.split('.')[0];// 获取主机名的第一部分
const checkHost = routeByHosts(hostTop);
hub_host = checkHost[0]; // 获取上游地址
const fakePage = checkHost[1];
console.log(`域名头部: ${hostTop}\n反代地址: ${hub_host}\n伪装首页: ${fakePage}`);
const isUuid = isUUID(pathname.split('/')[1].split('/')[0]);

if (屏蔽爬虫UA.some(fxxk => userAgent.includes(fxxk)) && 屏蔽爬虫UA.length > 0){
//首页改成一个nginx伪装页
return new Response(await nginx(), {
headers: {
'Content-Type': 'text/html; charset=UTF-8',
},
});
}

const conditions = [
isUuid,
pathname.includes('/_'),
pathname.includes('/r'),
pathname.includes('/v2/user'),
pathname.includes('/v2/orgs'),
pathname.includes('/v2/_catalog'),
pathname.includes('/v2/categories'),
pathname.includes('/v2/feature-flags'),
pathname.includes('search'),
pathname.includes('source'),
pathname === '/',
pathname === '/favicon.ico',
pathname === '/auth/profile',
];

if (conditions.some(condition => condition) && (fakePage === true || hostTop == 'docker')) {
if (env.URL302){
return Response.redirect(env.URL302, 302);
} else if (env.URL){
if (env.URL.toLowerCase() == 'nginx'){
//首页改成一个nginx伪装页
return new Response(await nginx(), {
headers: {
'Content-Type': 'text/html; charset=UTF-8',
},
});
} else return fetch(new Request(env.URL, request));
}

const newUrl = new URL("https://registry.hub.docker.com" + pathname + url.search);

// 复制原始请求的标头
const headers = new Headers(request.headers);

// 确保 Host 头部被替换为 hub.docker.com
headers.set('Host', 'registry.hub.docker.com');

const newRequest = new Request(newUrl, {
method: request.method,
headers: headers,
body: request.method !== 'GET' && request.method !== 'HEAD' ? await request.blob() : null,
redirect: 'follow'
});

return fetch(newRequest);
}

// 修改包含 %2F 和 %3A 的请求
if (!/%2F/.test(url.search) && /%3A/.test(url.toString())) {
let modifiedUrl = url.toString().replace(/%3A(?=.*?&)/, '%3Alibrary%2F');
url = new URL(modifiedUrl);
console.log(`handle_url: ${url}`)
}

// 处理token请求
if (url.pathname.includes('/token')) {
let token_parameter = {
headers: {
'Host': 'auth.docker.io',
'User-Agent': getReqHeader("User-Agent"),
'Accept': getReqHeader("Accept"),
'Accept-Language': getReqHeader("Accept-Language"),
'Accept-Encoding': getReqHeader("Accept-Encoding"),
'Connection': 'keep-alive',
'Cache-Control': 'max-age=0'
}
};
let token_url = auth_url + url.pathname + url.search
return fetch(new Request(token_url, request), token_parameter)
}

// 修改 /v2/ 请求路径
if (/^\/v2\/[^/]+\/[^/]+\/[^/]+$/.test(url.pathname) && !/^\/v2\/library/.test(url.pathname)) {
url.pathname = url.pathname.replace(/\/v2\//, '/v2/library/');
console.log(`modified_url: ${url.pathname}`)
}

// 更改请求的主机名
url.hostname = hub_host;

// 构造请求参数
let parameter = {
headers: {
'Host': hub_host,
'User-Agent': getReqHeader("User-Agent"),
'Accept': getReqHeader("Accept"),
'Accept-Language': getReqHeader("Accept-Language"),
'Accept-Encoding': getReqHeader("Accept-Encoding"),
'Connection': 'keep-alive',
'Cache-Control': 'max-age=0'
},
cacheTtl: 3600 // 缓存时间
};

// 添加Authorization头
if (request.headers.has("Authorization")) {
parameter.headers.Authorization = getReqHeader("Authorization");
}

// 发起请求并处理响应
let original_response = await fetch(new Request(url, request), parameter)
let original_response_clone = original_response.clone();
let original_text = original_response_clone.body;
let response_headers = original_response.headers;
let new_response_headers = new Headers(response_headers);
let status = original_response.status;

// 修改 Www-Authenticate 头
if (new_response_headers.get("Www-Authenticate")) {
let auth = new_response_headers.get("Www-Authenticate");
let re = new RegExp(auth_url, 'g');
new_response_headers.set("Www-Authenticate", response_headers.get("Www-Authenticate").replace(re, workers_url));
}

// 处理重定向
if (new_response_headers.get("Location")) {
return httpHandler(request, new_response_headers.get("Location"))
}

// 返回修改后的响应
let response = new Response(original_text, {
status,
headers: new_response_headers
})
return response;
}
};

/**
 * 处理HTTP请求
 * @param {Request} req 请求对象
 * @param {string} pathname 请求路径
 */
function httpHandler(req, pathname) {
const reqHdrRaw = req.headers

// 处理预检请求
if (req.method === 'OPTIONS' &&
reqHdrRaw.has('access-control-request-headers')
) {
return new Response(null, PREFLIGHT_INIT)
}

let rawLen = ''

const reqHdrNew = new Headers(reqHdrRaw)

const refer = reqHdrNew.get('referer')

let urlStr = pathname

const urlObj = newUrl(urlStr)

/** @type {RequestInit} */
const reqInit = {
method: req.method,
headers: reqHdrNew,
redirect: 'follow',
body: req.body
}
return proxy(urlObj, reqInit, rawLen)
}

/**
 * 代理请求
 * @param {URL} urlObj URL对象
 * @param {RequestInit} reqInit 请求初始化对象
 * @param {string} rawLen 原始长度
 */
async function proxy(urlObj, reqInit, rawLen) {
const res = await fetch(urlObj.href, reqInit)
const resHdrOld = res.headers
const resHdrNew = new Headers(resHdrOld)

// 验证长度
if (rawLen) {
const newLen = resHdrOld.get('content-length') || ''
const badLen = (rawLen !== newLen)

if (badLen) {
return makeRes(res.body, 400, {
'--error': `bad len: ${newLen}, except: ${rawLen}`,
'access-control-expose-headers': '--error',
})
}
}
const status = res.status
resHdrNew.set('access-control-expose-headers', '*')
resHdrNew.set('access-control-allow-origin', '*')
resHdrNew.set('Cache-Control', 'max-age=1500')

// 删除不必要的头
resHdrNew.delete('content-security-policy')
resHdrNew.delete('content-security-policy-report-only')
resHdrNew.delete('clear-site-data')

return new Response(res.body, {
status,
headers: resHdrNew
})
}

async function ADD(envadd) {
var addtext = envadd.replace(/[ |"'\r\n]+/g, ',').replace(/,+/g, ',');// 将空格、双引号、单引号和换行符替换为逗号
//console.log(addtext);
if (addtext.charAt(0) == ',') addtext = addtext.slice(1);
if (addtext.charAt(addtext.length -1) == ',') addtext = addtext.slice(0, addtext.length - 1);
const add = addtext.split(',');
//console.log(add);
return add ;
}

先send尝试请求是否正常返回，然后点击部署按钮

配置自己的域名

自己域名的配置需要一段时间生效，稍作等待即可。

验证

直接在浏览器种打开上述配置的域名

在未开启代理的情况下很迅速的打开了docker

通过下载镜像测试

首先执行以下命令配置环境，下面这个docker镜像链接是我的，记得替换成你自己的。执行之后可以正常拉取镜像就说明成功了。

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://dockerhub.allbs.xyz"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

视频教程

如何将一个工程或者一个目录导出为树形结构

2024-06-03T03:57:00.000Z

[!前言]
对于经常写笔记或者写文档得同学来说，经常会需要获取一个项目工程下得目录结构，那么如何在不需要下载或者安装插件来达到这个目的呢？

示例

只含有三级目录

包含文件得四级文件树

指定忽略部分文件或者文件夹，比如target目录，logs目录

使用方法

新建脚本

在你需要输出目录结构得文件夹下新建.sh脚本，名称随意，比如叫tree.sh

输入脚本代码

#!/bin/bash

# 获取当前脚本的名称
script_name=$(basename "$0")
output_file="tree_output.txt"

# 定义读取 .gitignore 文件的函数
read_gitignore() {
    local directory="$1"
    gitignore_file="$directory/.gitignore"
    if [[ -f "$gitignore_file" ]]; then
        # 读取 .gitignore 文件并排除注释和空行
        GITIGNORE_RULES=($(grep -Ev '^\s*#|^\s*$' "$gitignore_file"))
    else
        GITIGNORE_RULES=()
    fi
    # 将脚本名称和输出文件添加到排除列表
    GITIGNORE_RULES+=("$script_name" "$output_file")
}

# 检查文件或文件夹是否应该被忽略
is_excluded() {
    local path="$1"
    local relative_path="${path#$directory/}"
    local match_exclude=0  # 是否匹配到排除规则
    local match_include=0  # 是否匹配到包含规则（例外）

    # 转换为相对路径，并确保路径不以斜杠开头
    relative_path=$(echo "$relative_path" | sed 's/^\///')

    # 遍历 .gitignore 规则
    for rule in "${GITIGNORE_RULES[@]}"; do
        local original_rule="$rule"
        local is_inclusion=0  # 默认为排除规则
        if [[ "${rule:0:1}" == "!" ]]; then
            is_inclusion=1  # 如果是例外规则
            rule="${rule:1}"  # 移除开头的感叹号
        fi

        # 替换通配符 * 和 ?
        local pattern="${rule//\*/.*}"
        pattern="${pattern//\?/.}"

        # 根据规则中的斜杠位置构建不同的正则表达式
        if [[ "$rule" == /* ]]; then
            pattern="${pattern#/}"
            pattern="^$pattern($|/.*)$"
        elif [[ "$rule" == */ ]]; then
            pattern="${pattern%/}"
            pattern="^$pattern(/.*|$)"
        elif [[ "$rule" == */* ]]; then
            pattern="($|^.*/)$pattern($|/.*)$"
        else
            pattern="($|^.*/)$pattern($|/.*)$"
        fi

        # 检查路径匹配
        if [[ "$relative_path" =~ $pattern ]]; then
            if [[ "$is_inclusion" -eq 1 ]]; then
                match_include=1  # 匹配到例外规则，标记为包含
            else
                match_exclude=1  # 匹配到排除规则，标记为排除
            fi
        fi
    done

    # 如果匹配到包含规则，返回0（不忽略）
    # 如果匹配到排除规则且没有匹配到包含规则，返回1（忽略）
    if [[ "$match_include" -eq 1 ]]; then
        return 0
    elif [[ "$match_exclude" -eq 1 ]]; then
        return 1
    else
        return 0  # 默认不忽略
    fi
}

# 定义全局数组来记录每层级的计数
declare -a count_stack
declare -a index_stack

# 定义递归函数来打印目录结构
print_tree() {
    local directory="$1"
    local prefix="$2"
    local exclude_files="$3"
    local level="$4"
    local max_level="$5"

    # 递归到达最大层级时返回
    if [[ -n "$max_level" && "$level" -gt "$max_level" ]]; then
        return
    fi

    # 获取当前目录下的所有文件和文件夹
    shopt -s nullglob
    local items=("$directory"/*)
    shopt -u nullglob
    local count=${#items[@]}

    count_stack[$level]=$count
    index_stack[$level]=0

    while [[ ${index_stack[$level]} -lt ${count_stack[$level]} ]]; do
        local item="${items[${index_stack[$level]}]}"
        local base_name=$(basename "$item")
        local is_last=$((index_stack[$level] == count - 1))

        index_stack[$level]=$((index_stack[$level] + 1))

        # 跳过应该被 .gitignore 排除的文件夹和文件
if [[ "$apply_gitignore" == "y" ]]; then
is_excluded "$item"
if [[ $? -eq 1 ]]; then  # 检查 is_excluded 的返回值，如果为 1 则忽略
continue
fi
fi


        # 确定当前项的前缀符号
        if [ "$is_last" == "1" ]; then
            current_prefix="${prefix}└── $base_name"
            new_prefix="${prefix}    "
        else
            current_prefix="${prefix}├── $base_name"
            new_prefix="${prefix}│   "
        fi

        if [ -d "$item" ]; then
            # 打印目录名
            echo "$current_prefix"
            # 保存目录名到输出变量
            output_tree+="$current_prefix"$'\n'
            # 递归调用自己
            print_tree "$item" "$new_prefix" "$exclude_files" $((level + 1)) "$max_level"
        elif [ "$exclude_files" != "y" ]; then
            # 打印文件名
            echo "$current_prefix"
            # 保存文件名到输出变量
            output_tree+="$current_prefix"$'\n'
        fi
    done
}

# 获取当前目录的树型结构
directory="$(pwd)"

# 询问用户是否应用 .gitignore 中的内容
read -p "是否应用 .gitignore 中的内容? (y/n): " apply_gitignore

# 如果选择不应用，则清空排除列表
if [ "$apply_gitignore" == "n" ]; then
    GITIGNORE_RULES=()
else
    # 读取 .gitignore 文件
    read_gitignore "$directory"
fi

# 询问用户是否不包含文件
read -p "输出的树是否不包含文件? (y/n): " exclude_files

# 询问用户输出的层级
read -p "请输入输出的层级 (默认输出所有层级): " max_level

# 初始化输出变量
output_tree=""

# 打印并保存树型结构
echo "$(basename "$directory")"
output_tree+="$(basename "$directory")"$'\n'
print_tree "$directory" "" "$exclude_files" 1 "$max_level"

# 询问用户是否导出树型结构
read -p "是否导出这个输出的树? (y/n): " export_tree

if [ "$export_tree" == "y" ]; then
    echo -e "$output_tree" > "$output_file"
    echo "树型结构已导出到 $output_file"
fi

双击运行

运行过程中会有需要交互得地方

是否应用 .gitignore 中的内容?

我们知道git提交会配置.gitignore来忽略不想提交得内容，spring boot中得target目录、logs目录等，前端得.vscode目录等，我们并不想将这些内容输出到文件树中，就在第一个用户交互得地方输入y。

输出的树是否不包含文件?

如果输入y则会将所有文件输出到结果得树中。

请输入输出的层级 (默认输出所有层级):

默认为所有层级，输入数字则输出数字对应得层级

是否导出这个输出的树? (y/n)

最后是导出这个树到txt文件中，便于复制使用

mysql的增量备份和全量备份的方法

2024-05-30T05:15:00.000Z

区别

全量备份是指备份整个数据库的所有数据。
增量备份是指仅备份自上次备份以来更改的数据。

全量备份

全量备份的主要方法是使用 mysqldump 工具进行逻辑备份，或直接复制 MySQL 数据目录进行物理备份。

使用 `mysqldump` 进行全量备份

1	mysqldump -u 用户名 -p 数据库名 > 备份文件.sql

示例：

1	mysqldump -u root -p mydatabase > /path/to/backup/mydatabase_full_backup.sql

直接复制数据目录

停止 MySQL 服务：

1	sudo systemctl stop mysql

1	sudo cp -R /var/lib/mysql /path/to/backup/

启动 MySQL 服务：

1	sudo systemctl start mysql

增量备份

增量备份通常依赖于 MySQL 的二进制日志（binlog），因为这些日志记录了所有对数据库进行更改的操作。通过备份这些日志文件，可以实现增量备份。

配置二进制日志

首先需要确保 MySQL 配置启用了二进制日志。在 MySQL 配置文件（通常是 /etc/my.cnf 或 /etc/mysql/my.cnf）中添加或修改以下行：

1 2	[mysqld] log-bin=mysql-bin

然后重启 MySQL 服务以应用更改：

1	sudo systemctl restart mysql

全量备份与增量备份的组合使用

进行一次全量备份：

1	mysqldump -u 用户名 -p --all-databases --flush-logs --master-data=2 > /path/to/backup/full_backup.sql

定期备份二进制日志：
将新的二进制日志文件复制到备份目录。例如，可以使用以下脚本定期复制二进制日志：

#!/bin/bash
BINLOG_DIR="/var/lib/mysql"
BACKUP_DIR="/path/to/backup/binlogs"

cp $BINLOG_DIR/mysql-bin.* $BACKUP_DIR/

可以将该脚本添加到 cron 作业中，每天或每小时运行一次：

1	crontab -e

添加如下行以每小时运行一次增量备份脚本：

1	0 * * * * /path/to/backup/binlog_backup.sh

恢复数据

恢复全量备份

恢复全量备份文件：

1	mysql -u 用户名 -p < /path/to/backup/full_backup.sql

恢复增量备份

确保已应用全量备份。
应用二进制日志文件：

1	mysqlbinlog /path/to/backup/binlogs/mysql-bin.* \| mysql -u 用户名 -p

根据日志恢复数据的原理

2024-05-30T05:15:00.000Z

[!前言]
根据日志恢复数据的流程涉及到两个主要阶段：重做（REDO）和撤销（UNDO）。这些过程利用了 MySQL 的二进制日志（binlog）和重做日志（redo log）

1. 日志文件概述

二进制日志（binlog）： 记录所有对数据库进行更改的操作，包括所有提交的事务。这些日志用于增量备份和数据恢复。
重做日志（redo log）： 记录所有将要执行的操作，用于在崩溃恢复过程中重新应用未提交的事务。
撤销日志（undo log）： 记录事务在执行过程中修改前的数据，用于在事务回滚时撤销未提交的更改。

2. 检查点

检查点（checkpoint）是数据库系统中的一个机制，用于定期将内存中的数据刷新到磁盘，并记录一个时间点。在 MySQL 中，检查点由 InnoDB 存储引擎管理，主要有以下作用：

将缓冲池中的脏页（dirty pages）刷新到磁盘，减少崩溃恢复时需要重做的工作量。
在检查点之后，只需从该检查点开始应用重做日志，减少恢复时间。

3. 恢复流程概述

当数据库崩溃或发生故障时，恢复流程通常包括以下几个步骤：

读取检查点信息： 从检查点文件读取最后一个检查点的位置。
应用重做日志（REDO）： 从检查点位置开始，应用重做日志中的操作以恢复数据。
撤销未提交的事务（UNDO）： 撤销在崩溃时未提交的事务，确保数据一致性。

4. 具体恢复流程

步骤 1：读取检查点信息

检查点文件（ib_logfile0、ib_logfile1 等）包含最后一个检查点的位置。恢复过程从读取这些文件开始，确定从哪个位置开始应用重做日志。

步骤 2：应用重做日志（REDO）

从检查点开始，逐步应用重做日志中的操作。重做日志包含所有已提交和部分提交的事务操作。这些操作包括插入、更新和删除操作。重做日志的应用确保所有已提交的事务在数据恢复后仍然是提交状态。

REDO流程：
1. 从检查点位置开始读取重做日志。
2. 对每个日志条目，检查事务状态。
3. 如果事务已提交，重做该操作。
4. 如果事务未提交，暂时跳过。

  flowchart TD    A[数据库崩溃] --> B[读取检查点信息]    B --> C[读取重做日志文件]    C --> D{是否有更多日志条目？}    D --> |是| E[读取下一条日志]    E --> F{日志条目类型}    F --> |事务提交| G[应用日志条目]    F --> |事务未提交| H[跳过日志条目]    G --> D    H --> D    D --> |否| I[重做过程完成]

步骤 3：撤销未提交的事务（UNDO）

在完成重做操作后，接下来是撤销未提交的事务。这部分操作依赖于撤销日志（undo log）。撤销日志记录了每个事务在修改数据前的状态。

UNDO流程：
1. 读取撤销日志，找到所有未提交的事务。
2. 按照撤销日志中的记录，逐步撤销每个未提交事务的操作。
3. 确保所有未提交的事务都被撤销，恢复数据的一致性。

  flowchart TD    A[重做过程完成] --> B[读取撤销日志文件]    B --> C{是否有更多未提交事务？}    C --> |是| D[读取下一条未提交事务]    D --> E[查找事务对应的更改]    E --> F[撤销事务更改]    F --> C    C --> |否| G[撤销过程完成]

恢复示例

假设数据库在执行过程中崩溃，以下是一个详细的恢复示例：

读取检查点信息：
- 从检查点文件中读取最后一个检查点的位置，例如文件 ib_logfile0。
应用重做日志（REDO）：
- 从检查点位置开始，读取重做日志文件 ib_logfile0 和 ib_logfile1。
- 应用重做日志中的所有已提交事务，例如：
  - 事务 A：插入操作（已提交）。
  - 事务 B：更新操作（未提交）。
  - 事务 C：删除操作（已提交）。
撤销未提交的事务（UNDO）：
- 查找撤销日志，找到未提交的事务 B。
- 撤销事务 B 的更新操作，将数据恢复到事务 B 之前的状态。
  通过以上步骤，数据库可以从崩溃中恢复，并确保数据的一致性和完整性。完整得流程图如下:

  flowchart TB    A[数据库崩溃] --> B[读取检查点信息]        B --> C[读取重做日志文件]    C --> D{是否有更多日志条目？}    D --> |是| E[读取下一条日志]    E --> F{日志条目类型}    F --> |事务提交| G[应用日志条目]    F --> |事务未提交| H[跳过日志条目]    G --> D    H --> D    D --> |否| I[重做过程完成]    I --> J[读取撤销日志文件]        J --> K{是否有更多未提交事务？}    K --> |是| L[读取下一条未提交事务]    L --> M[查找事务对应的更改]    M --> N[撤销事务更改]    N --> K    K --> |否| O[撤销过程完成]        O --> P[恢复完成]

数据传输和储存，常见的校验方法说明及其应用实现

2024-05-27T03:33:00.000Z

奇偶校验（Parity Check）

原理：

奇偶校验是一种简单的错误检测机制，通过增加一个校验位（奇偶位）来使整个数据包的1的数量为奇数或偶数。

仅能检测单比特错误，无法纠正错误。
实现简单，适用于低错误率的场景。

类型：

奇校验（Odd Parity）：整个数据包中1的数量为奇数。
偶校验（Even Parity）：整个数据包中1的数量为偶数。

示例：

假设数据包为1010001。

奇校验：原数据中1的数量为3（奇数），所以校验位为0，数据包变为10100010。
偶校验：原数据中1的数量为3（奇数），所以校验位为1，数据包变为10100011。
如果接收方收到的数据中1的数量不符合预期的奇偶性，则表示数据包存在错误。

应用场景：

低错误率的简单通信系统：例如串行通信协议（如RS-232），用于基本的硬件通信。
存储设备：用于检测内存中的单比特错误。
数据传输：用于简单的网络协议和设备间数据传输。

java实现

public class ParityCheck {

    // 方法：计算奇校验位
    public static int calculateOddParity(int[] data) {
        int parity = 0;
        for (int bit : data) {
            parity ^= bit; // 异或操作
        }
        return parity;
    }

    // 方法：计算偶校验位
    public static int calculateEvenParity(int[] data) {
        int parity = 1;
        for (int bit : data) {
            parity ^= bit; // 异或操作
        }
        return parity;
    }

    // 方法：验证奇校验
    public static boolean verifyOddParity(int[] dataWithParity) {
        int parity = 0;
        for (int bit : dataWithParity) {
            parity ^= bit; // 异或操作
        }
        return parity == 0; // 奇校验：最终结果应为0
    }

    // 方法：验证偶校验
    public static boolean verifyEvenParity(int[] dataWithParity) {
        int parity = 1;
        for (int bit : dataWithParity) {
            parity ^= bit; // 异或操作
        }
        return parity == 0; // 偶校验：最终结果应为0
    }

    public static void main(String[] args) {
        int[] data = {1, 0, 1, 0, 0, 1}; // 示例数据

        // 计算奇校验位
        int oddParity = calculateOddParity(data);
        System.out.println("奇校验位: " + oddParity);

        // 计算偶校验位
        int evenParity = calculateEvenParity(data);
        System.out.println("偶校验位: " + evenParity);

        // 添加校验位到数据末尾（奇校验）
        int[] dataWithOddParity = new int[data.length + 1];
        System.arraycopy(data, 0, dataWithOddParity, 0, data.length);
        dataWithOddParity[data.length] = oddParity;

        // 添加校验位到数据末尾（偶校验）
        int[] dataWithEvenParity = new int[data.length + 1];
        System.arraycopy(data, 0, dataWithEvenParity, 0, data.length);
        dataWithEvenParity[data.length] = evenParity;

        // 验证奇校验
        boolean isOddParityValid = verifyOddParity(dataWithOddParity);
        System.out.println("奇校验结果: " + (isOddParityValid ? "有效" : "无效"));

        // 验证偶校验
        boolean isEvenParityValid = verifyEvenParity(dataWithEvenParity);
        System.out.println("偶校验结果: " + (isEvenParityValid ? "有效" : "无效"));
    }
}

CRC校验（Cyclic Redundancy Check）

原理：

CRC校验是一种更复杂的错误检测方法，通过将数据视为一个大多项式，然后对这个多项式进行模一个预定的生成多项式的除法操作，得到一个余数（CRC校验码）。这个余数被附加到数据末尾进行传输。

能检测多比特错误，通常用于数据链路层协议。
计算复杂度较高，但错误检测能力强。

示例：

假设数据包为1101011011，生成多项式为1011（对应于x^3 + x + 1）。

将数据末尾加上生成多项式的位数-1个0，即1101011011000。
用生成多项式1011对上述数据进行二进制除法，得到余数100。
余数作为校验码附加到数据末尾，即数据包变为1101011011100。
接收方进行相同的除法操作，如果余数为0，则表示数据没有错误。

应用场景：

网络通信：广泛应用于网络层和数据链路层协议（如以太网、PPP、HDLC等）来检测传输数据中的错误。
存储设备：如硬盘、光盘等，用于数据块的错误检测。
无线通信：用于无线传输协议，保证数据完整性。

java代码实现

CRC-32

import java.util.zip.CRC32;

public class CRCCheck {

    // 方法：计算CRC32校验码
    public static long calculateCRC32(byte[] data) {
        CRC32 crc32 = new CRC32();
        crc32.update(data);
        return crc32.getValue();
    }

    // 方法：验证CRC32校验码
    public static boolean verifyCRC32(byte[] data, long expectedCRC) {
        long calculatedCRC = calculateCRC32(data);
        return calculatedCRC == expectedCRC;
    }

    public static void main(String[] args) {
        String input = "Hello, world!"; // 示例输入数据
        byte[] data = input.getBytes();

        // 计算CRC32校验码
        long crcValue = calculateCRC32(data);
        System.out.println("CRC32校验码: " + Long.toHexString(crcValue));

        // 验证CRC32校验码
        boolean isValid = verifyCRC32(data, crcValue);
        System.out.println("CRC32校验结果: " + (isValid ? "有效" : "无效"));

        // 修改数据后验证CRC32
        data[0] = 'h'; // 修改数据的第一个字节
        isValid = verifyCRC32(data, crcValue);
        System.out.println("修改后CRC32校验结果: " + (isValid ? "有效" : "无效"));
    }
}

CRC-8（对应于`x^8 + x^2 + x + 1`）

public class CRC8 {

    // CRC-8 多项式 (x^8 + x^2 + x + 1)
    private static final int POLYNOMIAL = 0x07;
    // 初始化值
    private static final int INITIAL_VALUE = 0x00;

    // 方法：计算CRC-8校验码
    public static int calculateCRC8(byte[] data) {
        int crc = INITIAL_VALUE;

        for (byte b : data) {
            crc ^= b; // 异或操作

            for (int i = 0; i < 8; i++) {
                if ((crc & 0x80) != 0) {
                    crc = (crc << 1) ^ POLYNOMIAL;
                } else {
                    crc <<= 1;
                }
            }
        }

        return crc & 0xFF; // 取低8位作为CRC-8校验码
    }

    // 方法：验证CRC-8校验码
    public static boolean verifyCRC8(byte[] data, int expectedCRC) {
        int calculatedCRC = calculateCRC8(data);
        return calculatedCRC == expectedCRC;
    }

    public static void main(String[] args) {
        String input = "Hello, CRC-8!"; // 示例输入数据
        byte[] data = input.getBytes();

        // 计算CRC-8校验码
        int crcValue = calculateCRC8(data);
        System.out.println("CRC-8校验码: " + Integer.toHexString(crcValue));

        // 验证CRC-8校验码
        boolean isValid = verifyCRC8(data, crcValue);
        System.out.println("CRC-8校验结果: " + (isValid ? "有效" : "无效"));

        // 修改数据后验证CRC-8
        data[0] = 'h'; // 修改数据的第一个字节
        isValid = verifyCRC8(data, crcValue);
        System.out.println("修改后CRC-8校验结果: " + (isValid ? "有效" : "无效"));
    }
}

CRC-16（对应于`x^16 + x^12 + x^5 + 1`）

public class CRC16 {

    // CRC-16-CCITT 多项式 (x^16 + x^12 + x^5 + 1)
    private static final int POLYNOMIAL = 0x1021;
    // 初始化值
    private static final int INITIAL_VALUE = 0xFFFF;

    // 方法：计算CRC-16校验码
    public static int calculateCRC16(byte[] data) {
        int crc = INITIAL_VALUE;

        for (byte b : data) {
            crc ^= (b << 8); // 将当前字节移位到高8位

            for (int i = 0; i < 8; i++) {
                if ((crc & 0x8000) != 0) {
                    crc = (crc << 1) ^ POLYNOMIAL;
                } else {
                    crc <<= 1;
                }
            }
        }

        return crc & 0xFFFF; // 取低16位作为CRC-16校验码
    }

    // 方法：验证CRC-16校验码
    public static boolean verifyCRC16(byte[] data, int expectedCRC) {
        int calculatedCRC = calculateCRC16(data);
        return calculatedCRC == expectedCRC;
    }

    public static void main(String[] args) {
        String input = "Hello, CRC-16!"; // 示例输入数据
        byte[] data = input.getBytes();

        // 计算CRC-16校验码
        int crcValue = calculateCRC16(data);
        System.out.println("CRC-16校验码: " + Integer.toHexString(crcValue));

        // 验证CRC-16校验码
        boolean isValid = verifyCRC16(data, crcValue);
        System.out.println("CRC-16校验结果: " + (isValid ? "有效" : "无效"));

        // 修改数据后验证CRC-16
        data[0] = 'h'; // 修改数据的第一个字节
        isValid = verifyCRC16(data, crcValue);
        System.out.println("修改后CRC-16校验结果: " + (isValid ? "有效" : "无效"));
    }
}

海明码校验（Hamming Code）

原理：

海明码不仅能检测错误，还能纠正单比特错误。它通过在数据中插入多个校验位来实现。这些校验位的位置根据2的幂指数确定，并且每个校验位检查特定位置的位的组合。

能检测和纠正单比特错误，部分情况还能检测多比特错误。
适用于需要高可靠性的内存和存储系统。

示例：

假设数据包为1011。

确定需要插入的校验位位置。对于4位数据，需要3个校验位，位置为1, 2, 4。
在原数据中插入校验位，初步数据包变为_ _ 1 _ 0 1 1。
计算校验位的值：
- 第1位校验位计算位置1, 3, 5, 7的位，得到1。
- 第2位校验位计算位置2, 3, 6, 7的位，得到0。
- 第4位校验位计算位置4, 5, 6, 7的位，得到1。
最终数据包变为1010111。
在接收时，如果发现校验位不一致，可以通过校验位的位置组合确定并纠正错误位。

应用场景：

内存错误检测和纠正：用于ECC（错误检测和纠正）内存，确保计算机内存中的数据完整性。
计算机网络：用于简单的数据链路层协议，确保数据包的完整性。
嵌入式系统：用于对可靠性要求较高的嵌入式系统中，检测和纠正单比特错误。

java代码实现

import java.util.ArrayList;

public class HammingCode {

    // 方法：计算和插入校验位
    public static int[] generateHammingCode(int[] data) {
        int r = 0; // 校验位数量
        int m = data.length; // 数据位数量

        // 计算需要的校验位数量 r
        while (Math.pow(2, r) < (m + r + 1)) {
            r++;
        }

        int[] hammingCode = new int[m + r];
        int j = 0;

        // 插入校验位位置
        for (int i = 0; i < hammingCode.length; i++) {
            if (Math.pow(2, j) - 1 == i) {
                hammingCode[i] = 0; // 暂时填0
                j++;
            } else {
                hammingCode[i] = data[i - j];
            }
        }

        // 计算校验位的值
        for (int i = 0; i < r; i++) {
            int position = (int) Math.pow(2, i);
            int value = 0;

            for (int k = position - 1; k < hammingCode.length; k += 2 * position) {
                for (int l = k; l < k + position && l < hammingCode.length; l++) {
                    value ^= hammingCode[l];
                }
            }
            hammingCode[position - 1] = value;
        }

        return hammingCode;
    }

    // 方法：验证海明码
    public static int verifyHammingCode(int[] hammingCode) {
        int r = 0;

        // 计算校验位数量 r
        while (Math.pow(2, r) < (hammingCode.length + 1)) {
            r++;
        }

        int errorPosition = 0;

        // 计算校验位并找出错误位置
        for (int i = 0; i < r; i++) {
            int position = (int) Math.pow(2, i);
            int value = 0;

            for (int k = position - 1; k < hammingCode.length; k += 2 * position) {
                for (int l = k; l < k + position && l < hammingCode.length; l++) {
                    value ^= hammingCode[l];
                }
            }
            if (value != 0) {
                errorPosition += position;
            }
        }

        return errorPosition;
    }

    public static void main(String[] args) {
        int[] data = {1, 0, 1, 1}; // 示例数据

        // 生成海明码
        int[] hammingCode = generateHammingCode(data);
        System.out.print("生成的海明码: ");
        for (int bit : hammingCode) {
            System.out.print(bit);
        }
        System.out.println();

        // 验证海明码
        int errorPosition = verifyHammingCode(hammingCode);
        System.out.println("海明码校验结果: " + (errorPosition == 0 ? "无错误" : "错误位置：" + errorPosition));

        // 模拟一个错误
        hammingCode[2] ^= 1;
        errorPosition = verifyHammingCode(hammingCode);
        System.out.println("修改后海明码校验结果: " + (errorPosition == 0 ? "无错误" : "错误位置：" + errorPosition));

        // 修正错误
        if (errorPosition != 0) {
            hammingCode[errorPosition - 1] ^= 1;
            System.out.print("修正后的海明码: ");
            for (int bit : hammingCode) {
                System.out.print(bit);
            }
            System.out.println();
        }
    }
}

校验和（Checksum）

原理：

校验和是一种简单的错误检测方法，通过将数据分块后对每块数据进行求和操作，最后将和值附加到数据末尾进行传输。接收方重新计算和值，如果与接收到的和值一致，则表示数据没有错误。

示例：

假设数据包为1010001和1100101（两块数据）。

每块数据转为十进制：1010001为81，1100101为101。
求和：81 + 101 = 182。
将和值转为二进制：182为10110110。
将和值附加到数据包末尾进行传输。
接收方对接收的数据重新计算和值，若一致，则数据无误。

应用场景：

互联网协议：如TCP/IP中的IPv4头部校验和、UDP校验和、TCP校验和，用于确保数据包头部和负载的完整性。
文件传输：在文件传输协议（如FTP）中，用于验证文件的完整性。
嵌入式系统：用于嵌入式设备的固件校验，确保代码和数据的正确性。

java代码实现

计算数据的校验和。
将校验和附加到数据的末尾进行传输。
接收方计算接收到的数据的校验和，并与传输的校验和进行比较，以验证数据完整性。

public class Checksum {

    // 方法：计算校验和
    public static int calculateChecksum(byte[] data) {
        int checksum = 0;

        for (byte b : data) {
            checksum += (b & 0xFF); // 将byte转换为无符号int
        }

        // 将校验和限制在一个字节范围内（0-255）
        checksum = checksum & 0xFF;

        return checksum;
    }

    // 方法：验证校验和
    public static boolean verifyChecksum(byte[] data, int expectedChecksum) {
        int calculatedChecksum = calculateChecksum(data);
        return calculatedChecksum == expectedChecksum;
    }

    public static void main(String[] args) {
        String input = "Hello, Checksum!"; // 示例输入数据
        byte[] data = input.getBytes();

        // 计算校验和
        int checksumValue = calculateChecksum(data);
        System.out.println("校验和: " + Integer.toHexString(checksumValue));

        // 验证校验和
        boolean isValid = verifyChecksum(data, checksumValue);
        System.out.println("校验和结果: " + (isValid ? "有效" : "无效"));

        // 模拟一个错误
        data[0] = 'h'; // 修改数据的第一个字节
        isValid = verifyChecksum(data, checksumValue);
        System.out.println("修改后校验和结果: " + (isValid ? "有效" : "无效"));
    }
}

鲁棒哈希（Robust Hash）

原理：

哈希校验利用哈希函数将数据映射到一个固定长度的值（哈希值）。这种方法可以快速检测数据的完整性，但不能纠正错误。常见的哈希函数包括MD5、SHA-1、SHA-256等。

示例：

假设数据包为Hello, world!。

使用SHA-256哈希函数计算哈希值，得到7f83b1657ff1fc53b92dc18148a1d65dfa13573eaa04c20e82e8f142b245e69d。
将哈希值附加到数据末尾进行传输。
接收方对接收的数据重新计算哈希值，若一致，则数据无误。

应用场景：

文件完整性校验：如MD5、SHA系列哈希算法，广泛用于校验文件下载和传输的完整性。
数据存储：用于校验数据库和文件系统中的数据完整性。
数字签名和证书：确保数据未被篡改，用于验证数据的真实性和完整性。

循环冗余校验（LRC）

原理：

纵向冗余校验（LRC）通过对数据每列的值进行求和操作，得到的结果作为校验码附加到数据末尾。适用于多块数据的校验。

示例：

假设数据包为：
1101 1011 0110

每列求和：
- 第1列：1 + 1 + 0 = 2（取模2得到0）
- 第2列：1 + 0 + 1 = 2（取模2得到0）
- 第3列：0 + 1 + 1 = 2（取模2得到0）
- 第4列：1 + 1 + 0 = 2（取模2得到0）
校验码为0000。
将校验码附加到数据包末尾进行传输，接收方进行相同的列求和校验。

应用场景：

工业通信协议：如Modbus协议中，用于检测数据帧的错误。
数据记录和传输：用于某些存储和传输设备，确保数据块的一致性。
简单嵌入式系统：用于低资源需求的系统中，进行基本的错误检测。

瑞德-所罗门码（Reed-Solomon Code）

原理：

瑞德-所罗门码是一种广泛应用于通信和存储的纠错码，能够纠正多比特错误。通过将数据视为多项式，利用有限域上的多项式运算实现错误检测和纠正。

示例：

假设数据包为[1, 2, 3, 4]，生成多项式为[1, 0, 1]。

数据视为多项式1 + 2x + 3x^2 + 4x^3。
生成多项式为1 + x^2。
利用有限域上的多项式运算得到校验码，假设为[2, 1]。
将校验码附加到数据包末尾进行传输。
接收方通过多项式除法和有限域运算检测和纠正错误。

应用场景：

光盘存储：如CD、DVD、Blu-ray，确保在读写过程中纠正错误。
数字电视和广播：用于地面、卫星和有线数字电视传输，保证视频和音频数据的完整性。
数据存储：用于RAID系统和固态硬盘中的数据纠错。
通信系统：如卫星通信、深空通信和移动通信，用于增强信号的可靠性。

博斯-乔杜里-霍克因码（BCH Code）

原理：

BCH码是一种适用于多比特错误纠正的编码方法，通过生成多项式和解码算法实现高效的错误检测和纠正。

示例：

假设数据包为[1011011]，生成多项式为x^4 + x + 1。

数据视为多项式1 + 0x + 1x^2 + 1x^3 + 1x^4。
生成多项式为x^4 + x + 1。
利用多项式除法得到校验码，假设为[1101]。
将校验码附加到数据包末尾进行传输。
接收方通过多项式除法检测和纠正错误。

应用场景：

NAND闪存：用于固态硬盘和存储卡中的数据纠错，确保高密度存储的可靠性。
卫星通信：用于深空探测器的通信系统，增强数据传输的可靠性。
移动通信：用于移动通信标准（如LTE、WiMAX）中的数据纠错，保证信号的稳定性。
QR码：用于二维码中的数据纠错，提高条码扫描的可靠性。

数据结构-----树的说明和应用

2024-05-26T03:33:00.000Z

定义

树是一种由结点和边组成的非线性数据结构，具有分层次的结构，每个结点都有零个或多个子结点。

术语

结点（Node）：树的基本元素，包含数据和指向子结点的链接。
根结点（Root）：树的顶端结点，没有父结点。
子结点（Child Node）：一个结点的下一级结点。
父结点（Parent Node）：一个结点的上一级结点。
叶结点（Leaf Node）：没有子结点的结点。
内部结点（Internal Node）：有至少一个子结点的结点。
边（Edge）：连接父结点和子结点的链接。
路径（Path）：从一个结点到另一个结点的边的序列。
深度（Depth）：从根结点到某个结点的路径长度。
高度（Height）：从某个结点到叶结点的最长路径长度。
子树（Subtree）：由某个结点及其所有后代结点组成的树。

树的分类

二叉树（Binary Tree）：每个结点最多有两个子结点。

完全二叉树（Complete Binary Tree）：除最后一层外，其他层的结点都是满的，且最后一层的结点从左到右依次排列。

满二叉树（Full Binary Tree）：每个结点要么没有子结点，要么有两个子结点。

// 只有一个结点（没有子结点）
    1

// 三层满二叉树（每个结点有两个子结点）
        1
       / \
      2   3
     / \ / \
    4  5 6  7

平衡二叉树（Balanced Binary Tree）：任何结点的左右子树的高度差不超过1。平衡二叉树的结构确保了较好的搜索、插入和删除性能，使这些操作的时间复杂度保持在 𝑂(log⁡𝑛) 水平。

// 例1
4
   / \
  2   6
 / \ / \
1  3 5  7
// 例2
10
   /  \
  5    15
 / \     \
3   7    20
 \
  4

二叉搜索树（Binary Search Tree, BST）：对每个结点，其左子树所有结点的值均小于该结点的值，右子树所有结点的值均大于该结点的值。每二叉搜索树的这种特性使得查找、插入和删除操作的平均时间复杂度为 𝑂(log⁡𝑛)

// 插入顺序：5, 3, 7, 2, 4, 6, 8
        5
       / \
      3   7
     / \ / \
    2  4 6  8
// 插入顺序：10, 5, 15, 3, 7, 12, 18, 1, 4, 6, 8, 11, 13, 17, 19
            10
          /    \
        5       15
      /  \     /   \
     3    7   12   18
    / \  / \  / \  / \
   1  4 6  8 11 13 17 19

N叉树（N-ary Tree）：每个结点最多有N个子结点。

特殊树：

B树（B-Tree）：用于数据库和文件系统的自平衡树。

假设我们有一个阶数为3的B树（每个节点最多可以有2个关键字，3个子节点）。
插入顺序：10, 20, 5, 6, 12, 30, 7, 17

1
2
3

       [10, 20]
      /    |    \
[5, 6, 7]  [12]  [17, 30]

在这个B树中：

根节点包含关键字10和20，有三个子节点。
左子节点包含关键字5、6和7，没有子节点（叶子节点）。
中子节点包含关键字12，没有子节点（叶子节点）。
右子节点包含关键字17和30，没有子节点（叶子节点）。
插入更多的关键字
插入关键字21后，B树的结构会发生变化，需要进行分裂和调整。

1
2
3

        [10, 20]
      /     |     \
[5, 6, 7]  [12]  [17, 21, 30]

当插入关键字4后，左子节点会分裂：

              [10, 20]
           /     |     \
    [5, 6]      [12]  [17, 21, 30]
   /    \
[4]    [7]

通过这种结构，B树确保了所有叶子节点都在同一层，并且每个节点的子节点数在给定范围内（这里为2到3）。这使得B树在处理大量数据时仍然保持高效的操作性能。

B+树（B+ Tree）：B树的变种，所有值都存储在叶结点，内部结点只存储键。

B+树是B树的一种变种，所有值都存储在叶子节点中，而内部节点只存储键用于索引。B+树在数据库和文件系统中有广泛应用，因为它能有效地进行范围查询。
假设我们有一个阶数为3的B+树（每个节点最多可以有2个关键字，3个子节点）。
插入顺序：10, 20, 5, 6, 12, 30, 7, 17

1
2
3

    [10, 20]
   /    |    \
[5, 6, 7]  [12, 17]  [20, 30]

在这个B+树中：

根节点包含关键字10和20，有三个子节点。
左子节点包含关键字5、6和7，指向包含这些值的叶子节点。
中子节点包含关键字12和17，指向包含这些值的叶子节点。
右子节点包含关键字20和30，指向包含这些值的叶子节点。

叶子节点链接

叶子节点通常通过链表相连，以便于范围查询。

    [10, 20]
    /    |    \
/[5, 6, 7]/->[12, 17]/->[20, 30]/

插入更多的关键字

插入关键字21后，B+树的结构会发生变化，需要进行分裂和调整。

1
2
3

    [10, 20]
   /    |    \
[5, 6, 7]  [12, 17]  [20, 21, 30]

当插入关键字4后，左子节点会分裂：

           [10, 20]
         /      |      \
[4, 5, 6]     [12, 17]     [20, 21, 30]
    \          \            /
     [7]        [12, 17]    [20, 21, 30]

红黑树（Red-Black Tree）：一种平衡二叉搜索树，确保基本操作的时间复杂度为O(log n)。

红黑树每个节点都包含一个额外的颜色属性，可以是红色或黑色。红黑树通过以下规则保持平衡：

每个节点是红色或黑色。
根节点是黑色。
所有叶子节点（NIL节点）是黑色。
如果一个节点是红色，则它的两个子节点都是黑色（不能有两个连续的红色节点）。
从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
插入顺序：10, 20, 30, 15, 25, 5, 1

        10(黑)
       /     \
    5(红)     20(黑)
   /        /     \
1(黑)     15(红)  25(黑)
                  \
                  30(红)

在这个红黑树中：

根节点10是黑色的。
结点20是黑色的，左子节点15是红色的，右子节点25是黑色的。
结点25的右子节点30是红色的。
结点5是红色的，左子节点1是黑色的。

插入规则和调整

插入10：树为空，10作为根节点，颜色为黑色。
插入20：20作为10的右子节点，颜色为红色。
插入30：30作为20的右子节点，颜色为红色。违反规则4，需要调整。
- 将20和10的颜色交换，然后进行左旋。
插入15：15作为20的左子节点，颜色为红色。
插入25：25作为20的右子节点，颜色为红色。需要调整。
- 进行颜色调整并右旋。
插入5：5作为10的左子节点，颜色为红色。
插入1：1作为5的左子节点，颜色为黑色（插入调整为红色，但因规则调整为黑色）。
最终形成的红黑树符合所有红黑树的规则，保持平衡。红黑树的插入和删除操作通过颜色变化和旋转来保持树的平衡，使得其基本操作的时间复杂度为 𝑂(log⁡𝑛)O(logn)。

AVL树：一种平衡二叉搜索树，严格保持平衡，左右子树的高度差不超过1。

每个节点的左右子树的高度差（平衡因子）不超过1。AVL树通过旋转操作来保持平衡。
插入顺序：10, 20, 30, 40, 50, 25
插入10, 20, 30

这导致了不平衡，需要进行左旋转：

  20
 /  \
10    30

插入40

插入50

这导致了不平衡，需要进行左旋转：

插入25

这导致了不平衡，需要进行右左旋转：

     30
    /  \
  20    40
  / \     \
10  25    50

最终形成的AVL树符合AVL树的平衡规则，每个节点的左右子树高度差不超过1。

AVL树的旋转操作

右旋转（Right Rotation）
左旋转（Left Rotation）
左右旋转（Left-Right Rotation）
右左旋转（Right-Left Rotation）
这些旋转操作通过调整树的结构来保持平衡。每次插入或删除操作后，AVL树都会检查平衡因子并进行相应的旋转，以确保树的平衡。AVL树的基本操作的时间复杂度为 𝑂(log⁡𝑛)O(logn)。

Trie（前缀树）：用于快速检索字符串集合中的元素。

每个节点代表一个字符，路径从根节点到某个节点的字符串表示该节点的前缀。
插入单词： “hello”, “hi”, “her”, “hero”, “heat”

          root
         /  |  \
        h   h   h
       /   / \   \
      e   i   e   e
     /   |   / \   \
    l    i  r   a   r
   / \       |   |   \
  l   r      o   t    o
 /          /
o          r

在这个Trie中：

根节点是空的（root）。
第一层的节点表示单词的第一个字符：“h”。
第二层的节点表示单词的第二个字符：“e”、“i”。
第三层及以下的节点依次表示单词的后续字符。
每个单词通过从根节点到叶子节点的路径表示：
“hello” 路径为：root -> h -> e -> l -> l -> o
“hi” 路径为：root -> h -> i
“her” 路径为：root -> h -> e -> r
“hero” 路径为：root -> h -> e -> r -> o
“heat” 路径为：root -> h -> e -> a -> t

Trie的应用

Trie广泛用于以下场景：

自动补全：输入法和搜索引擎中的自动补全功能。
拼写检查：快速查找和纠正单词的拼写错误。
前缀查询：查找具有共同前缀的所有单词。
IP路由（最长前缀匹配）：在网络路由中的应用。
Trie通过共享前缀实现了高效的存储和检索，在处理大量字符串时具有显著的优势。

树的表示方法

链式存储（Linked Representation）：每个结点包含数据和指向子结点的指针。
顺序存储（Sequential Representation）：用数组来表示树，特别适用于完全二叉树。

树的遍历

示例一个树

      A
     / \
    B   C
   / \   \
  D   E   F
 / \
G   H

深度优先遍历（DFS, Depth-First Search）：

前序遍历（Preorder Traversal）：先访问根结点，再遍历左子树，最后遍历右子树。
中序遍历（Inorder Traversal）：先遍历左子树，再访问根结点，最后遍历右子树。
后序遍历（Postorder Traversal）：先遍历左子树，再遍历右子树，最后访问根结点。

搜索顺序

沿着树的深度遍历树的节点。遍历一条分支直到最后一个节点，然后回溯并遍历其他分支。

1	A -> B -> D -> G -> H -> E -> C -> F

DFS 图示

    A
   / 
  B  
 / 
D  
/ \
G  H
\
 E
 \
  C
   \
    F

广度优先遍历（BFS, Breadth-First Search）：

层序遍历（Level-order Traversal）：按层次逐层遍历。

搜索顺序

从根节点开始，沿着树的宽度遍历树的节点。

1	A -> B -> C -> D -> E -> F -> G -> H

BFS 图示

    A
   / \
  B   C
 / \   \
D   E   F
/ \
G   H

树的操作

插入（Insertion）：在树中添加新结点。
删除（Deletion）：从树中删除指定结点。
查找（Search）：在树中查找特定结点。
合并（Merge）：将两棵树合并成一棵树。
分裂（Split）：将一棵树分裂成两棵树。

树的应用

文件系统：文件和目录的组织结构。
表达式树：表示和计算算术表达式。
决策树：用于机器学习中的分类和回归问题。
XML/HTML解析：DOM树结构，用于解析和操作XML/HTML文档。
路由算法：网络中的路径选择。
数据索引：如数据库索引（B树、B+树）。
字符串处理：如Trie用于快速字符串检索。

树的复杂度分析

时间复杂度：讨论树的各种操作（如插入、删除、查找）的时间复杂度。
空间复杂度：树的存储空间需求分析。

树的实现

编程语言示例：使用常见编程语言（如Python、Java、C++）实现各种树结构和操作。
案例分析：具体应用中的树结构实现，如实现一个简单的文件系统或表达式计算器。
以python实现一个表达式计算器为例

数据结构

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

表达式树的构建和计算

class ExpressionTree:
    def __init__(self):
        self.root = None

    def build_tree(self, expression):
        stack = []
        for char in expression:
            if char.isdigit():
                node = TreeNode(char)
                stack.append(node)
            else:
                node = TreeNode(char)
                node.right = stack.pop()
                node.left = stack.pop()
                stack.append(node)
        self.root = stack.pop()

    def evaluate(self, node):
        if node.left is None and node.right is None:
            return int(node.value)
        left_value = self.evaluate(node.left)
        right_value = self.evaluate(node.right)
        if node.value == '+':
            return left_value + right_value
        elif node.value == '-':
            return left_value - right_value
        elif node.value == '*':
            return left_value * right_value
        elif node.value == '/':
            return left_value / right_value

    def calculate(self):
        if self.root is None:
            raise ValueError("The expression tree is empty")
        return self.evaluate(self.root)

    def print_tree(self, node, level=0):
        if node is not None:
            self.print_tree(node.right, level + 1)
            print(' ' * 4 * level + '->', node.value)
            self.print_tree(node.left, level + 1)

# 示例表达式
expression = "34+5*"
tree = ExpressionTree()
tree.build_tree(expression)

print("表达式树:")
tree.print_tree(tree.root)

result = tree.calculate()
print("计算结果:", result)

详细解释

TreeNode 类：用于表示树中的每个节点。每个节点要么是一个操作数（数字），要么是一个操作符（+、-、*、/）。
ExpressionTree 类：用于表示整个表达式树。
- build_tree 方法：从后缀表达式构建表达式树。使用栈将操作数推入栈中，遇到操作符时，弹出两个操作数作为左右子节点。
- evaluate 方法：递归地计算表达式树的值。
- calculate 方法：计算表达式树的值，从根节点开始。
- print_tree 方法：打印表达式树的结构。

示例运行结果

对于后缀表达式 "34+5*"，表达式树的结构为：

计算结果为 (3 + 4) * 5，即 7 * 5，结果为 35。

写一个脚本合并相同名称的文件至新建文件夹中

2024-05-15T07:57:00.000Z

[!前言]
有时候会碰到这种情况，一个文件夹中存在大量文件，有些文件名称相同但是文件类型不同。如果想要将名称相同的文件保存至一个新建的文件夹中，这个文件夹以共同的名称命名，应该如何操作？

类似结构如图

目标是创建这是AAA,这是BBB,这是CCC文件夹并将相同名称的文件移动进去

创建脚本

如果是windows则新建一个文件并重新命名为merge_files.sh,如果是linux则nano merge_files.sh或者vim merge_files.sh

输入以下内容

#!/bin/bash

# 列出所有文件
list_files() {
    local directory="$1"
    find "$directory" -maxdepth 1 -type f
}

# 显示文件列表
display_files() {
    local files=("$@")
    echo "List of files:"
    for file in "${files[@]}"; do
        echo "$file"
    done
}

# 合并文件
merge_files() {
    local files=("$@")
    declare -A file_dict
    local errors=()

    # 分类文件
    for file in "${files[@]}"; do
        base_name=$(basename "$file" | sed 's/\.[^.]*$//')
        if [[ -z "${file_dict["$base_name"]}" ]]; then
            file_dict["$base_name"]=""
        fi
        file_dict["$base_name"]+="$file;"
    done

    # 创建新文件夹并移动文件
    for base_name in "${!file_dict[@]}"; do
        IFS=';' read -r -a file_list <<< "${file_dict["$base_name"]}"
        new_folder="$(dirname "${file_list[0]}")/$base_name"
        mkdir -p "$new_folder"
        for file in "${file_list[@]}"; do
            mv "$file" "$new_folder" 2>/dev/null
            if [ $? -ne 0 ]; then
                errors+=("$file")
            fi
        done
        echo "Files moved to $new_folder"
    done

    # 列出出错的文件
    if [ ${#errors[@]} -gt 0 ]; then
        echo "The following files could not be moved:"
        for error in "${errors[@]}"; do
            echo "$error"
        done
    else
        echo "All files moved successfully."
    fi
}

# 主函数
main() {
    if [ $# -ne 1 ]; then
        echo "Usage: $0 "
        exit 1
    fi

    local directory="$1"

    if [ ! -d "$directory" ]; then
        echo "Error: Directory $directory does not exist."
        exit 1
    fi

    mapfile -t files < <(list_files "$directory")
    display_files "${files[@]}"

    read -p "Do you want to merge files with the same name but different extensions? (Y/N): " choice
    if [[ "$choice" == "Y" || "$choice" == "y" ]]; then
        merge_files "${files[@]}"
    else
        echo "No files were merged."
    fi
}

# 运行主函数
main "$@"

运行脚本

1	./merge_files.sh 需要合并的文件夹路径

不同的shell目录展示会有所不同，我这用的是cmder所以如上图展示，其他可能直接目录是E://test

执行以及结果输出

为何建议使用markdown来写文档、写笔记

2024-05-08T01:41:00.000Z

[!前言]
Markdown 是一种轻量级标记语言，自2004年由John Gruber和Aaron Swartz共同创建以来，它已经成为编写网页内容和文档的一种流行方式。Markdown 的设计初衷是使文本编写尽可能简单和直观，同时仍然具备转换为HTML的能力，以便于发布到互联网上。同时随着限制编译器的发展markdown可以随意的转换为word、pdf等格式，其转换后的样式同markdown预览一致，使得你可以不用学习繁琐的word各种操作也能写出漂亮的word和pdf。

优势

简洁性和易读性：Markdown 的语法非常简单，使用纯文本就能实现丰富的格式展示，比如标题、列表、代码块、表格等。这种简单性保证了即使在没有格式化的情况下，文档的内容也是可读的。
易于学习：Markdown 的语法元素非常少，常用的标记符号不超过十种，这使得用户可以在很短的时间内学会并开始使用Markdown进行文档编写。
跨平台兼容：Markdown 文档为纯文本文件，可以在任何平台和设备上编辑和查看，无需担心兼容性问题。
灵活转换：Markdown 文档可以轻松转换为HTML、PDF、Word等多种格式，方便发布到不同的平台和媒体。
广泛支持：许多博客平台、论坛和文档编辑器支持Markdown，甚至在GitHub等代码托管平台上，Markdown 也成为文档和说明的标准格式。
自定义样式：很多markdown编辑器都支持自定义css样式，这样可以让你一份基本的markdown文档呈现出千姿百态，只要是你能想的出的画面，而不需要对文档本身进行任何渲染优化。

基本用法

标题：通过在文字前面添加#符号来创建标题。标题从#到######共六级，数量越多级别越低。
1
2
3
# 一级标题
## 二级标题
### 三级标题
加粗和斜体：使用**加粗文字，使用*或_使文字倾斜。
1
2
**这是加粗的文字**
*这是斜体文字*

这是加粗的文字
这是斜体文字

列表：使用-或*创建无序列表，使用数字加.创建有序列表。
1
2
3
4
5
6
- 列表项一
- 列表项二
- 列表项三

1. 第一项
2. 第二项
列表项一
- 列表项二
- 列表项三
1. 第一项
2. 第二项
链接和图片：使用[描述](链接)插入链接，使用![描述](图片链接)插入图片。
1
2
[Google](http://google.com)
![Logo](http://logo.png)
代码块：使用反引号`将代码包围起来创建单行代码，使用三个反引号包围一段代码创建代码块。
1
2
`printf()`
printf(“Hello, world!”);
1
2
3
```

- **引用**：使用`>`符号进行文本引用。
这是一段引用文本。上方前言就是这种形式
1
2

- **表格**：使用`|`和`-`来创建表格。
标题1 标题2 标题3
内容1 内容2 内容3
内容4 内容5 内容6

便捷操作markdown的软件

vscode:装个markdown插件即可
typora
Yank Note：github上开源，功能挺强
Obisdian：功能极强，但是上手难度很高
语雀
有道云文档(几年前用的时候发现其图片是自己按照一定规则存放在本地，文章拷贝到其他编译器图片不兼容，所以放弃了)

转为博客

现代很多博客的框架都是使用markdown转换为网页的，如wordpress、hexo、vuepress等。大量开源的主题可以让你随心所欲的定制页面样式。

微信公众号

微信公众号其中的格式肯定不是人为的一个个去格式化的，有大量平台可以将文档格式化漂亮的样式，以墨滴为例：
使用不同主题渲染文档，很方便的将同一份文档表达成不同的形式：

使用播放源直接收看全世界上万频道

2024-05-07T03:40:00.000Z

[!前言]
部分频道会有较大延迟，肯定比不上IPTV，但优势在于能收看全世界绝大数的频道，没有任何限制。

说明

IPTV（互联网协议电视）是一种通过互联网协议（IP）传输电视内容的技术，允许用户通过互联网观看电视节目，而不是通过传统的地面广播、卫星或有线电视。IPTV常用来提供实时电视、视频点播和互动电视等服务。

m3u 是一种播放列表文件格式，通常用于存储多媒体播放列表信息。它可以包含音视频文件的本地路径或网络URL列表。对于 IPTV 来说，m3u 文件通常包含电视台的直播流 URL 列表，每个 URL 都对应一个电视台的直播频道或视频点播资源。用户可以通过 m3u 文件获取到频道列表，并通过支持 m3u 的媒体播放器或 IPTV 应用播放对应的频道。

m3u 文件在 IPTV 中起到了组织和分发电视台直播流信息的作用。

github上搜索播放源

查看star数最多的这个

链接直达: https://github.com/iptv-org/iptv

查看m3u文件

可以直接把m3u文件导入到播放器中或者直接使用播放器打开m3u文件链接

1 2	# 所有频道地址 https://iptv-org.github.io/iptv/index.m3u

按照频道类型划分

总的: https://iptv-org.github.io/iptv/index.category.m3u

分类	频道数	播放地址
动画	65	`https://iptv-org.github.io/iptv/categories/animation.m3u`
汽车	17	`https://iptv-org.github.io/iptv/categories/auto.m3u`
商业	65	`https://iptv-org.github.io/iptv/categories/business.m3u`
经典	52	`https://iptv-org.github.io/iptv/categories/classic.m3u`
喜剧	53	`https://iptv-org.github.io/iptv/categories/comedy.m3u`
烹饪	25	`https://iptv-org.github.io/iptv/categories/cooking.m3u`
文化	105	`https://iptv-org.github.io/iptv/categories/culture.m3u`
纪录片	68	`https://iptv-org.github.io/iptv/categories/documentary.m3u`
教育	121	`https://iptv-org.github.io/iptv/categories/education.m3u`
娱乐	438	`https://iptv-org.github.io/iptv/categories/entertainment.m3u`
家庭	42	`https://iptv-org.github.io/iptv/categories/family.m3u`
一般	1663	`https://iptv-org.github.io/iptv/categories/general.m3u`
儿童	208	`https://iptv-org.github.io/iptv/categories/kids.m3u`
立法	177	`https://iptv-org.github.io/iptv/categories/legislative.m3u`
生活	85	`https://iptv-org.github.io/iptv/categories/lifestyle.m3u`
电影	293	`https://iptv-org.github.io/iptv/categories/movies.m3u`
音乐	596	`https://iptv-org.github.io/iptv/categories/music.m3u`
新闻	829	`https://iptv-org.github.io/iptv/categories/news.m3u`
户外	51	`https://iptv-org.github.io/iptv/categories/outdoor.m3u`
轻松	5	`https://iptv-org.github.io/iptv/categories/relax.m3u`
宗教	611	`https://iptv-org.github.io/iptv/categories/religious.m3u`
科学	25	`https://iptv-org.github.io/iptv/categories/science.m3u`
系列	169	`https://iptv-org.github.io/iptv/categories/series.m3u`
购物	84	`https://iptv-org.github.io/iptv/categories/shop.m3u`
体育	211	`https://iptv-org.github.io/iptv/categories/sports.m3u`
旅行	37	`https://iptv-org.github.io/iptv/categories/travel.m3u`
天气	13	`https://iptv-org.github.io/iptv/categories/weather.m3u`
成人	0	`https://iptv-org.github.io/iptv/categories/xxx.m3u`
综合	4790	`https://iptv-org.github.io/iptv/categories/undefined.m3u`

按照语言划分

总的:https://iptv-org.github.io/iptv/index.language.m3u

分类	频道数	播放地址
Afghan Persian	5	`https://iptv-org.github.io/iptv/languages/prs.m3u`
Afrikaans	3	`https://iptv-org.github.io/iptv/languages/afr.m3u`
Albanian	61	`https://iptv-org.github.io/iptv/languages/sqi.m3u`
Alemannic	1	`https://iptv-org.github.io/iptv/languages/gsw.m3u`
Amharic	11	`https://iptv-org.github.io/iptv/languages/amh.m3u`
Arabic	401	`https://iptv-org.github.io/iptv/languages/ara.m3u`
Armenian	22	`https://iptv-org.github.io/iptv/languages/hye.m3u`
Assamese	7	`https://iptv-org.github.io/iptv/languages/asm.m3u`
Assyrian Neo-Aramaic	1	`https://iptv-org.github.io/iptv/languages/aii.m3u`
Aymara	1	`https://iptv-org.github.io/iptv/languages/aym.m3u`
Azerbaijani	24	`https://iptv-org.github.io/iptv/languages/aze.m3u`
Bashkir	1	`https://iptv-org.github.io/iptv/languages/bak.m3u`
Basque	8	`https://iptv-org.github.io/iptv/languages/eus.m3u`
Belarusian	3	`https://iptv-org.github.io/iptv/languages/bel.m3u`
Bengali	81	`https://iptv-org.github.io/iptv/languages/ben.m3u`
Bhojpuri	1	`https://iptv-org.github.io/iptv/languages/bho.m3u`
Bosnian	13	`https://iptv-org.github.io/iptv/languages/bos.m3u`
Bulgarian	36	`https://iptv-org.github.io/iptv/languages/bul.m3u`
Burmese	20	`https://iptv-org.github.io/iptv/languages/mya.m3u`
Catalan	53	`https://iptv-org.github.io/iptv/languages/cat.m3u`
Central Kurdish	2	`https://iptv-org.github.io/iptv/languages/ckb.m3u`
Chhattisgarhi	1	`https://iptv-org.github.io/iptv/languages/hne.m3u`
Chinese	154	`https://iptv-org.github.io/iptv/languages/zho.m3u`
Croatian	20	`https://iptv-org.github.io/iptv/languages/hrv.m3u`
Czech	36	`https://iptv-org.github.io/iptv/languages/ces.m3u`
Danish	22	`https://iptv-org.github.io/iptv/languages/dan.m3u`
Dhanwar (Nepal)	1	`https://iptv-org.github.io/iptv/languages/dhw.m3u`
Dhivehi	4	`https://iptv-org.github.io/iptv/languages/div.m3u`
Dholuo	1	`https://iptv-org.github.io/iptv/languages/luo.m3u`
Dimili	2	`https://iptv-org.github.io/iptv/languages/zza.m3u`
Dutch	204	`https://iptv-org.github.io/iptv/languages/nld.m3u`
English	2200	`https://iptv-org.github.io/iptv/languages/eng.m3u`
Estonian	10	`https://iptv-org.github.io/iptv/languages/est.m3u`
Ewe	1	`https://iptv-org.github.io/iptv/languages/ewe.m3u`
Faroese	1	`https://iptv-org.github.io/iptv/languages/fao.m3u`
Fataleka	1	`https://iptv-org.github.io/iptv/languages/far.m3u`
Finnish	30	`https://iptv-org.github.io/iptv/languages/fin.m3u`
French	472	`https://iptv-org.github.io/iptv/languages/fra.m3u`
Galician	15	`https://iptv-org.github.io/iptv/languages/glg.m3u`
Galolen	1	`https://iptv-org.github.io/iptv/languages/gal.m3u`
Georgian	9	`https://iptv-org.github.io/iptv/languages/kat.m3u`
German	290	`https://iptv-org.github.io/iptv/languages/deu.m3u`
Gikuyu	2	`https://iptv-org.github.io/iptv/languages/kik.m3u`
Goan Konkani	1	`https://iptv-org.github.io/iptv/languages/gom.m3u`
Greek	133	`https://iptv-org.github.io/iptv/languages/ell.m3u`
Greenlandic	2	`https://iptv-org.github.io/iptv/languages/kal.m3u`
Gujarati	11	`https://iptv-org.github.io/iptv/languages/guj.m3u`
Haitian	5	`https://iptv-org.github.io/iptv/languages/hat.m3u`
Hausa	1	`https://iptv-org.github.io/iptv/languages/hau.m3u`
Hebrew	14	`https://iptv-org.github.io/iptv/languages/heb.m3u`
Hindi	178	`https://iptv-org.github.io/iptv/languages/hin.m3u`
Hungarian	110	`https://iptv-org.github.io/iptv/languages/hun.m3u`
Icelandic	5	`https://iptv-org.github.io/iptv/languages/isl.m3u`
Indonesian	149	`https://iptv-org.github.io/iptv/languages/ind.m3u`
Inuktitut	1	`https://iptv-org.github.io/iptv/languages/iku.m3u`
Iranian Persian	1	`https://iptv-org.github.io/iptv/languages/pes.m3u`
Irish	5	`https://iptv-org.github.io/iptv/languages/gle.m3u`
Isekiri	1	`https://iptv-org.github.io/iptv/languages/its.m3u`
Italian	333	`https://iptv-org.github.io/iptv/languages/ita.m3u`
Japanese	98	`https://iptv-org.github.io/iptv/languages/jpn.m3u`
Javanese	3	`https://iptv-org.github.io/iptv/languages/jav.m3u`
Kannada	19	`https://iptv-org.github.io/iptv/languages/kan.m3u`
Kazakh	30	`https://iptv-org.github.io/iptv/languages/kaz.m3u`
Khmer	13	`https://iptv-org.github.io/iptv/languages/khm.m3u`
Kinyarwanda	3	`https://iptv-org.github.io/iptv/languages/kin.m3u`
Kirghiz	13	`https://iptv-org.github.io/iptv/languages/kir.m3u`
Konkani (macrolanguage)	2	`https://iptv-org.github.io/iptv/languages/kok.m3u`
Korean	110	`https://iptv-org.github.io/iptv/languages/kor.m3u`
Kurdish	26	`https://iptv-org.github.io/iptv/languages/kur.m3u`
Lahnda	1	`https://iptv-org.github.io/iptv/languages/lah.m3u`
Lao	15	`https://iptv-org.github.io/iptv/languages/lao.m3u`
Latin	3	`https://iptv-org.github.io/iptv/languages/lat.m3u`
Latvian	13	`https://iptv-org.github.io/iptv/languages/lav.m3u`
Letzeburgesch	9	`https://iptv-org.github.io/iptv/languages/ltz.m3u`
Lingala	2	`https://iptv-org.github.io/iptv/languages/lin.m3u`
Lithuanian	8	`https://iptv-org.github.io/iptv/languages/lit.m3u`
Macedonian	34	`https://iptv-org.github.io/iptv/languages/mkd.m3u`
Malay	19	`https://iptv-org.github.io/iptv/languages/msa.m3u`
Malayalam	74	`https://iptv-org.github.io/iptv/languages/mal.m3u`
Maltese	3	`https://iptv-org.github.io/iptv/languages/mlt.m3u`
Mandarin Chinese	5	`https://iptv-org.github.io/iptv/languages/cmn.m3u`
Maori	1	`https://iptv-org.github.io/iptv/languages/mri.m3u`
Marathi	17	`https://iptv-org.github.io/iptv/languages/mar.m3u`
Min Nan Chinese	1	`https://iptv-org.github.io/iptv/languages/nan.m3u`
Mongolian	21	`https://iptv-org.github.io/iptv/languages/mon.m3u`
Montenegrin	1	`https://iptv-org.github.io/iptv/languages/cnr.m3u`
Mycenaean Greek	1	`https://iptv-org.github.io/iptv/languages/gmy.m3u`
Nepali	16	`https://iptv-org.github.io/iptv/languages/nep.m3u`
Northern Kurdish	1	`https://iptv-org.github.io/iptv/languages/kmr.m3u`
Norwegian	9	`https://iptv-org.github.io/iptv/languages/nor.m3u`
Norwegian Bokmål	1	`https://iptv-org.github.io/iptv/languages/nob.m3u`
Oriya (macrolanguage)	8	`https://iptv-org.github.io/iptv/languages/ori.m3u`
Panjabi	27	`https://iptv-org.github.io/iptv/languages/pan.m3u`
Papiamento	11	`https://iptv-org.github.io/iptv/languages/pap.m3u`
Parsi-Dari	2	`https://iptv-org.github.io/iptv/languages/prd.m3u`
Pashto	20	`https://iptv-org.github.io/iptv/languages/pus.m3u`
Persian	111	`https://iptv-org.github.io/iptv/languages/fas.m3u`
Polish	39	`https://iptv-org.github.io/iptv/languages/pol.m3u`
Portuguese	377	`https://iptv-org.github.io/iptv/languages/por.m3u`
Quechua	1	`https://iptv-org.github.io/iptv/languages/que.m3u`
Romanian	127	`https://iptv-org.github.io/iptv/languages/ron.m3u`
Romany	1	`https://iptv-org.github.io/iptv/languages/rom.m3u`
Russian	337	`https://iptv-org.github.io/iptv/languages/rus.m3u`
Saint Lucian Creole French	2	`https://iptv-org.github.io/iptv/languages/acf.m3u`
Santali	1	`https://iptv-org.github.io/iptv/languages/sat.m3u`
Serbian	57	`https://iptv-org.github.io/iptv/languages/srp.m3u`
Serbo-Croatian	1	`https://iptv-org.github.io/iptv/languages/hbs.m3u`
Sindhi	2	`https://iptv-org.github.io/iptv/languages/snd.m3u`
Sinhala	11	`https://iptv-org.github.io/iptv/languages/sin.m3u`
Slovak	47	`https://iptv-org.github.io/iptv/languages/slk.m3u`
Slovenian	17	`https://iptv-org.github.io/iptv/languages/slv.m3u`
Somali	9	`https://iptv-org.github.io/iptv/languages/som.m3u`
Southern Kurdish	1	`https://iptv-org.github.io/iptv/languages/sdh.m3u`
Spanish	2227	`https://iptv-org.github.io/iptv/languages/spa.m3u`
Swahili	20	`https://iptv-org.github.io/iptv/languages/swa.m3u`
Swedish	20	`https://iptv-org.github.io/iptv/languages/swe.m3u`
Tagalog	20	`https://iptv-org.github.io/iptv/languages/tgl.m3u`
Tajik	16	`https://iptv-org.github.io/iptv/languages/tgk.m3u`
Tamil	69	`https://iptv-org.github.io/iptv/languages/tam.m3u`
Tatar	1	`https://iptv-org.github.io/iptv/languages/tat.m3u`
Telugu	33	`https://iptv-org.github.io/iptv/languages/tel.m3u`
Tetum	1	`https://iptv-org.github.io/iptv/languages/tet.m3u`
Thai	75	`https://iptv-org.github.io/iptv/languages/tha.m3u`
Tibetan	2	`https://iptv-org.github.io/iptv/languages/bod.m3u`
Tigrinya	2	`https://iptv-org.github.io/iptv/languages/tir.m3u`
Turkish	216	`https://iptv-org.github.io/iptv/languages/tur.m3u`
Turkmen	7	`https://iptv-org.github.io/iptv/languages/tuk.m3u`
Uighur	3	`https://iptv-org.github.io/iptv/languages/uig.m3u`
Ukrainian	84	`https://iptv-org.github.io/iptv/languages/ukr.m3u`
Urdu	59	`https://iptv-org.github.io/iptv/languages/urd.m3u`
Uzbek	18	`https://iptv-org.github.io/iptv/languages/uzb.m3u`
Vietnamese	75	`https://iptv-org.github.io/iptv/languages/vie.m3u`
Welsh	2	`https://iptv-org.github.io/iptv/languages/cym.m3u`
Western Frisian	1	`https://iptv-org.github.io/iptv/languages/fry.m3u`
Wolof	4	`https://iptv-org.github.io/iptv/languages/wol.m3u`
Yucatec Maya	1	`https://iptv-org.github.io/iptv/languages/yua.m3u`
Yue Chinese	9	`https://iptv-org.github.io/iptv/languages/yue.m3u`
Undefined	1304	`https://iptv-org.github.io/iptv/languages/undefined.m3u`

按照地区划分

总的 https://iptv-org.github.io/iptv/index.region.m3u

地区	频道数	播放列表链接
非洲	545	https://iptv-org.github.io/iptv/regions/afr.m3u
美洲	4134	https://iptv-org.github.io/iptv/regions/amer.m3u
阿拉伯世界	402	https://iptv-org.github.io/iptv/regions/arab.m3u
亚洲	3014	https://iptv-org.github.io/iptv/regions/asia.m3u
亚太地区	2046	https://iptv-org.github.io/iptv/regions/apac.m3u
东南亚国家联盟	400	https://iptv-org.github.io/iptv/regions/asean.m3u
巴尔干	667	https://iptv-org.github.io/iptv/regions/balkan.m3u
本努勒斯	245	https://iptv-org.github.io/iptv/regions/benelux.m3u
加勒比海	274	https://iptv-org.github.io/iptv/regions/carib.m3u
中美洲	333	https://iptv-org.github.io/iptv/regions/cenamer.m3u
中东欧	1045	https://iptv-org.github.io/iptv/regions/cee.m3u
中亚	82	https://iptv-org.github.io/iptv/regions/cas.m3u
独联体	459	https://iptv-org.github.io/iptv/regions/cis.m3u
欧洲	3324	https://iptv-org.github.io/iptv/regions/eur.m3u
欧洲、中东和非洲	4209	https://iptv-org.github.io/iptv/regions/emea.m3u
欧盟	2222	https://iptv-org.github.io/iptv/regions/eu.m3u
西班牙美洲	1836	https://iptv-org.github.io/iptv/regions/hispam.m3u
拉丁美洲	2143	https://iptv-org.github.io/iptv/regions/latam.m3u
拉丁美洲和加勒比海	2173	https://iptv-org.github.io/iptv/regions/lac.m3u
马格里布	60	https://iptv-org.github.io/iptv/regions/maghreb.m3u
中东	661	https://iptv-org.github.io/iptv/regions/mideast.m3u
中东和北非	712	https://iptv-org.github.io/iptv/regions/mena.m3u
北欧	101	https://iptv-org.github.io/iptv/regions/nord.m3u
北美洲	2781	https://iptv-org.github.io/iptv/regions/noram.m3u
北美	1958	https://iptv-org.github.io/iptv/regions/nam.m3u
北欧	137	https://iptv-org.github.io/iptv/regions/neur.m3u
大洋洲	84	https://iptv-org.github.io/iptv/regions/oce.m3u
南美洲	1371	https://iptv-org.github.io/iptv/regions/southam.m3u
南亚	634	https://iptv-org.github.io/iptv/regions/sas.m3u
东南亚	415	https://iptv-org.github.io/iptv/regions/sea.m3u
南欧	1138	https://iptv-org.github.io/iptv/regions/ser.m3u
撒哈拉以南非洲	454	https://iptv-org.github.io/iptv/regions/ssa.m3u
西非	195	https://iptv-org.github.io/iptv/regions/wafr.m3u
西欧	1014	https://iptv-org.github.io/iptv/regions/wer.m3u

如何使用

链接:https://github.com/iptv-org/awesome-iptv#apps

示例

mac

windows

单一源事件（SSE）的一个spring boot实现，常用来将服务端内容实时推送到前端展示

2024-05-06T03:49:00.000Z

[!前言]
不同于WebSockets提供了双向通信的能力，SSE只支持单向通信。但对于一些场景，如服务器向客户端发送通知或实时更新，SSE是一个简单且有效的选择。

说明

单一源事件（SSE）是一种用于实现服务器向客户端推送数据的网络技术。通常Web应用程序是基于请求-响应模式工作的，客户端需要定期向服务器发送请求以获取更新的数据。但是对于需要实时更新的应用，如聊天应用、股票市场更新等，这种轮询的方式效率不高。
SSE技术通过建立一次持久的连接，允许服务器主动向客户端发送数据，而不需要客户端发送请求。这种推送模式能够显著减少网络流量和服务器负载，同时实现实时更新。在SSE中，服务器向客户端发送一系列数据块，每个数据块以"event: "、"data: "和两个换行符开始，并以一个空行结束。客户端通过监听服务器发送的数据块来获取更新。

后端实现

以下模拟一个接口请求将每秒饭返回一条数据，持续十秒

package cn.allbs.sse.controller;  
  
import org.springframework.http.MediaType;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestParam;  
import org.springframework.web.bind.annotation.RestController;  
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;  
  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
/**  
 * 类 SSEController  
 * * @author ChenQi  
 * @date 2024/5/6  
 */@RestController  
public class SSEController {  
  
    private final ExecutorService executorService = Executors.newSingleThreadExecutor();  
  
    @GetMapping(value = "/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)  
    public SseEmitter receiveText(@RequestParam String question) {  
        SseEmitter emitter = new SseEmitter();  
        executorService.execute(() -> {  
            try {  
                // 处理接收到的文本内容  
                String processedText = processText(question);  
  
                // 将处理结果逐步发送给客户端  
                for (int i = 1; i <= 10; i++) {  
                    emitter.send(processedText.replace("问题", "回答") + i);  
                    Thread.sleep(1000); // 模拟每秒发送一个字符  
                }  
                emitter.complete(); // 发送完毕，关闭连接  
            } catch (Exception e) {  
                emitter.completeWithError(e); // 发生错误，关闭连接  
            }  
        });  
        return emitter;  
    }  
  
    // 在实际应用中，这里可以添加对文本内容的具体处理逻辑  
    private String processText(String text) {  
        return "这是问题:" + text;  
    }  
}

前端界面可以随意一点画下即可

  
  
  
    SSE Demo

访问页面

http://{ip}:{port}/index.html

实现效果

demo地址

https://github.com/chenqi92/spring-sse.git

不懂音乐也能创作歌曲

2024-04-24T02:41:00.000Z

创作教程

纯音乐

制作纯音乐比较简单，只要简单录入使用到的乐器和音乐风格即可生成

信息录入完成之后点击create创建即可，生成的歌曲如下：

第一首：

https://nas.allbs.cn:8888/cloudpic/2024/04/aa4fac6c77b31022a07f6248f1d148fc.mp3

第二首：

https://nas.allbs.cn:8888/cloudpic/2024/04/b07e480caa6147478651b4f2a00fb6c4.mp3

歌词创作

使用chatGPT直接生成

要求chatGPT生成歌词并且按照指定格式输出

歌词的形式可以为：

1	[instrumental intro][Verse 1] <歌词>[Chorus] <歌词>[Verse 2] <歌词>[Chorus] <歌词>[Bridge] <歌词>[Guitar solo][Chorus] <歌词>[Outro][End]

将歌词核心提取出来转为英文prompt输入Style of Music

将歌词、风格、曲名都输入到Suno中生成歌曲

生成歌曲一览

曲一

https://nas.allbs.cn:8888/cloudpic/2024/04/0846fe16aee80e98e51c4a010e312da7.mp3

曲二

https://nas.allbs.cn:8888/cloudpic/2024/04/42ec026e2dd1f73fb3463d668515ae8e.mp3

下载

网站地址

https://suno.com/create

生成漫画的ai

2024-04-23T05:41:00.000Z

使用说明

漫画风格

漫画布局

是否添加说明文字

按钮打开将会在漫画中添加说明文字

故事情节和视觉风格

可以切换得模型

默认得模型不收费,有可能连接超时,但是需要自己注册账号后获取token。可以切换到chatgpt的dall-e-3和gpt-4-turbo来使用

使用演示

效果展示

官方地址(需魔法)

https://huggingface.co/spaces/jbilcke-hf/ai-comic-factory

源码克隆

git clone https://huggingface.co/spaces/jbilcke-hf/ai-comic-factory

本地运行(node版本>18.17.0)

注册账号

https://huggingface.co/

token配置

获取token后配置在.env中运行

本地运行

1
2
3

npm install

next dev

视频解说，图片视频是如何生成的？

2024-04-22T07:41:00.000Z

[!前言]
为何抖音博主能够快速的制作一个个短视频，虽然绝大部分内容都是垃圾，但是肯定还是有部分人能够通过这种方式变现。下面就来教你如何实现。

ai生成剧本

能够自己写剧本，或者只是相对某个视频进行解说的，请忽略这一步往后看。
在chatGPT中直接让它生成剧本，如果对剧本不满足可以让它进行细微修改，我这边只是为了演示流程，就随便制作一个故事来示例了。

可以看到生成的剧本中有角色、画面、旁白和角色的对话内容。
以下内容为ai本次给到的剧本

### 视频脚本：《说谎的后果》

#### 风格说明
- **风格**：上海美术电影风格，动画色彩丰富，画面唯美。
- **时长**：5分钟

#### 角色
- **坤坤**：一只聪明但爱说谎的小狐狸
- **小兔米米**：坤坤的好朋友，天真善良
- **其他森林动物**：鸟儿、松鼠等

---

#### 开场画面
- **画面**：清晨的森林，阳光透过树叶，鸟儿在歌唱。
- **旁白**：“在一个阳光明媚的早晨，森林里的小动物们都在忙碌地开始新的一天。”

#### 第一场景：坤坤与小兔米米
- **画面**：坤坤与小兔米米在森林里玩耍。
- **旁白**：“这是小狐狸坤坤和他的好朋友小兔米米。坤坤聪明机智，但有时候会说些小谎言。”

#### 第二场景：坤坤的谎言
- **画面**：坤坤指着空空的篮子告诉米米那里有很多蘑菇。
- **旁白**：“今天，坤坤对米米说，他找到了一个满是蘑菇的地方。”
- **坤坤**（兴奋地）：“米米，跟我来，我带你去摘最大的蘑菇！”
- **小兔米米**（天真地）：“真的吗？我好兴奋啊！”

#### 第三场景：发现谎言
- **画面**：米米跟随坤坤到了指定地点，发现那里并没有蘑菇。
- **旁白**：“但当他们到达时，米米发现那里根本没有蘑菇。”
- **小兔米米**（失望地）：“坤坤，你为什么要骗我？”
- **坤坤**（尴尬地）：“我...我只是想和你一起玩游戏。”

#### 第四场景：后果与教训
- **画面**：米米悲伤地离开，其他动物也对坤坤表现出失望。
- **旁白**：“坤坤的小谎言让米米很伤心，其他小动物们也开始远离坤坤。”

#### 第五场景：坤坤的反思与改变
- **画面**：坤坤独自坐在树下，显得孤独和沮丧。
- **旁白**：“坤坤开始反思，他意识到说谎让他失去了朋友。”
- **坤坤**（自言自语）：“我不应该说谎。我需要向米米和其他朋友道歉。”

#### 结尾场景：和解与快乐的结局
- **画面**：坤坤向米米和其他动物诚恳地道歉，它们渐渐原谅他。
- **旁白**：“坤坤诚实地向大家道歉，小动物们看到他的改变，又重新接受了他。”
- **画面**：所有的动物一起在森林中玩耍，笑声和快乐充满整个森林。

#### 结尾字幕
- **画面**：夕阳下

的森林，动物们和睦相处。
- **旁白**：“坤坤学到了一个宝贵的教训：说谎总会被揭穿，而诚实才是最好的策略。”

---

### 视频脚本结尾
- **音乐渐起**：温馨、愉快的音乐作为背景。
- **字幕**：“诚实守信，友谊长存。”

根据画面让ai生成画面

将第一个画面内容清晨的森林，阳光透过树叶，鸟儿在歌唱。复制过去，并限定一下生成的图片的风格，比如可以设置为迪士尼，设置画面大小为16:9

ai绘制画面

获取画面的gen_id

获取画面的gen_id主要的目的就是保持多个画面风格的统一

继续生成其他画面

按照第一张图的方式将第二个画面继续生成图片。注意：为了保持画面风格的统一，必须加上gen_id，就是上一步给到的内容。

依法炮制所有画面

让多个图片变成一个视频故事

需要用到软件剪印。

图文成片

自由编辑文案，将上述文案中的旁白和对话拷贝进去。

点击生成视频—>使用本地素材

导入ai绘制的图片

将不同图片拖到下面的封面那一行，并左右拉动调整画面和旁白对应。

旁白期间过于单调，设置画面自动缩放

先在图片第一个位置标记一下添加关键帧

再在末尾或者靠近末尾的地方添加一个关键帧并设置缩放。

增加一点湖面特效

拖动并拉长新增的特效使其让整个画面都有特效

设置旁白的语音

选中下方的语音文字部分，右上角声音效果，选个比较适合的语音填入即可。

导出

在以上内容重新进行保证每个画面都有语音和字母后导出视频。

pdf转换工具推荐

2024-04-22T02:41:00.000Z

[!NOTE] 前言
前段时间受人之托需要把一个pdf中的表格提取出来，发现市面上工具要么收费，要么效果很差，要么就是又收费效果又差。

比较好的工具

I♥PDF: https://www.ilovepdf.com/zh-cn
PDF转换器: https://www.pdf2docx.cn/

效果对比

pdf中的效果

比较差的转换效果

里面包含大量的图片，很难直接使用

比较好的转换效果

明显没有转为图片的问题，而且样式也大体不差。

薅羊毛的一些小姿势

2024-04-20T03:40:00.000Z

[!NOTE] 引言
很多网站有每日签到，每日签到会给到一定的积分，积分可以兑换网站内的物品。但是每天人工去签到肯定很耽误时间，如果能够自动化这个操作，既节省了时间又薅到了羊毛。本文以github的workflow和可以自己搭建的青龙面板来实现这个操作。

青龙面板

京东签到、自动浇水、自动保价

前提

建议直接找台电脑、nas啥的部署一个青龙面板，因为我的路由器支持docker，我是直接部署在路由器里面的，路由器不支持的可以用电视盒子部署，家里啥设备都没有的就用工作电脑部署，如果还是没有那就没办法了。

青龙面板的安装

https://github.com/FlechazoPh/QLDependency

设置环境变量

想要实现以上功能肯定离不开token，京东token的获取可以用网页打开ipad端获取pt_key和pt_pin。
https://bean.m.jd.com/bean/signIndex.action
登录后打开F12从cookie中找到pt_key和pt_pin

青龙面板中环境变量配置如下

订阅脚本

创建订阅直接拉取写好的脚本库即可

名称中输入

1	ql repo https://js.jdpro.site/https://github.com/6dylan6/jdpro.git "jd_\|jx_\|jddj_" "backUp" "^jd[^_]\|USER\|JD\|function\|sendNotify\|utils"

定时规则输入

5 * * * *

点击确定即可
等待脚本自动拉取下来。
然后等待依赖管理中的依赖下载完成。

然后就可以等待脚本自动运行了

查看日志，观测脚本运行情况

吐槽一下，现在京东每天获取量有够低的，之前一天几百京东轻轻松松，现在一天10豆子。。。

看了示例的任务，其实其他的任务都是差不多的，照葫芦画瓢可以搞一些其他网站的定时任务，比如阿里云盘的自动签到之类的。

github的workflow

以掘金签到为例

网站: https://juejin.cn/

fork一下github上别人开发好的签到软件juejing_sign

其他网站同理，github有现成的，也可以根据想要的网站拦截一下签到的api接口，自己开发一下。

获取网站的cookies

F12随便找一个包含cookie的请求，将cookie复制

将cookie设置到fork之后的库中

点击那个绿色的按钮new repository secret

Name填入COOKIE
Secret填入刚才F12查到的cookie的那一大串内容
点击Add secret保存

启用自动运行

如图位置
点击Run workflow即可每天准时签到了

效果

如果不是自动签到，人为签到很难坚持几年不断的。

签到得到的积分可以抽奖或者用来换实物

如图都是以前抽到的东西，如果攒一攒倒是能换一个不错的实物了。

可以换的实物

各种好用的windows办公工具分享

2024-04-19T10:41:00.000Z

系统操作工具

everything

总所周知windows中想要查找一个文件有多费劲，这款软件就是为了解决这个问题，在全盘中不到一秒找到你想要的文件。

utools

utools是一个大杂烩，集成大量的功能，可以指定ctrl + space或者shift+space呼出面板，面板内通过搜索功能名称找到想要的功能，简而言之就是把所有windows里面可以用到的功能都放在这个呼出的面板中，下面说一说我常用的功能。

书签搜索，直接搜索书签名称自动在浏览器中打开。
配合everything查找文件，比如查找一个hj212
看小说，上班担心被发现摸鱼偷偷看小说怎么办，下载摸鱼阅读插件，在线搜索或者导入小说，以非常隐蔽的方式看小说。
不用去电脑桌面直接打开桌面软件
不用特意去找windows系统功能直接搜索打开功能
面板功能，设置为鼠标的某个键，点击这个键会呼出面板，面板可以取色，锁屏，测距等等。
粘贴板，将所有复制过的内容保存，可以后续再查找这些功能。
不同端的内容传输，比如不同电脑在线传文件等。
功能很多，就不一一列举了。

powerToys

微软官方开发的一款系统辅助的工具。

hosts文件修改
环境变量便捷修改

截图工具

pixpin

snipaste也用过，qq，微信自带的当然不用说，功能上肯定不如这款工具的。

影视软件

PotPlayer

这个工具知名度还是比较高的，可以看直播流，缺点就是一天到晚更新，都不知道更新个什么玩意。

音乐软件

音流

我知道肯定很多人用的qq音乐、网易云之类的，但是毕竟还是需要会员的，不能听歌自由。这款软件可以连接自建的音乐服务器，如群晖的DS audio、navidrome、webdav等。至于音乐资源，我想应该没人会操心这个。
https://www.hifini.com/ 这个网站上面基本有你想要的所有音乐。

密码保存

1password

可以自动填充网页中的密码，肯定比浏览器自带的密码储存工具要安全。但是收费比较贵。

bitwarden

除了比较丑没啥缺点，自建的密码服务，数据都保存在自己手里，比较安心，但是前提是自己的服务器不会被入侵。

录屏软件

bandicam

还是挺好用的，缺点是收费

录屏转gif工具

ScreenToGif

shell+ftp

Xshell+Xftp

连接远程服务器不可避免用到的工具。
如果有需要的可以在我公共号发送消息shell可以得到免费的xshell和xftp

文本

notepad++

抛开作者的立场来说，这款工具还是非常好用的，不用再忍受windows自带的记事本，好用的功能很多，就不一一列举，只说些我日常经常会用到的功能。

格式化代码片段
竖选替换，比如你有一堆文本，竖着部分特征是一致的，那么你可以竖着把这些东西选中并插入自己想要的内容。
正则替换，正则的强大不用说，指定替换想要的内容。
文件夹中所有内容替换，指定一个文件夹，将该文件夹下所有文件还有指定内容的字符替换为自己想要的内容。

笔记工具(最少都是支持markdown的，这个年代应该没人用word了吧)

obsidian

笔记工具从最开始的有道云->joplin->yank note(内置的功能默认是最强大的，而且是国人开发的，其实还是挺好用的)->语雀(阿里的毕竟是别人服务器，有一定风险)-> typora->obsidian。
obsidian入手门槛比较高，但是有大量的插件，基本可以满足你想要的任何功能。obsidian优缺点大概列举下。

上手难度很大，开发的人员并没有考虑到行业外人员使用的情况。
remotely save 同步笔记到不同客户端。
style setting使你自由定制软件界面，让他呈现你所满意的样式。
dataview 当你有大量笔记时，这个插件会带给你完全不一样的感觉。
image upload让你在笔记内粘贴图片时自动上传到图床中，避免笔记在不同端无法查看图片的问题。
双链不是默认支持的，需要VIP
支持导出word、pdf等

图片自动上传工具

picGo

开源软件，基本文档工具都支持，让你的图片自动上传到图床中，在你将md的笔记生成网页时也能正常查看图片。

地图下载器

太乐地图下载器

文件比较工具

Beyond Compare 4

文件预览工具

quickLook

实现mac那种space直接查看word、excel等文件内容而不用双击打开文件。

浏览器

推荐Chrome/Edge，其实大部分浏览器都是chromium内核。

Google Chrome

如果有梯子的话可以安装一些比较好用的插件让浏览器更加强大。

插件推荐

one Tab 收起tab，不至于一堆tab找不到自己想要的那个。
AdBlock 去除网页广告，用了这个插件，我已经忘记百度广告长什么样了。
IE Tab 一些比较极端的网站比如有些银行、比较老的摄像头需要依赖ie内核，可以使用这个插件解决这个问题。
书签同步同步不同客户端的书签
沉浸式翻译可以翻译英文网页内容，并且以段落形式让中文汉字跟在原版英文段落之后，体验极佳。
篡改猴在插件中安装插件，实现各种自定义的功能。比如让CSDN隐藏广告，并且调整页面的展示方式、知乎增强-跳过登录、京东自营过滤等等功能。

Edge

Edge可以不用梯子就下载这些插件，当然并不是所有插件都能找到。

免费的Copilot（需要梯子）

https://www.bing.com/chat
可以使用这个ai工具进行自己想要的功能，比如画图

拥有一台个人服务器，可以做哪些事情？

2024-04-13T04:23:00.000Z

[!NOTE] 前言
实际上买一台工控机做服务器成本并不高，几百块买个树莓派或者n5105、n100都是绰绰有余的，那么它们可以做哪些事情呢？

既是服务器也是软路由，配置为旁路由，一部分设备走旁路由，一部分设备走主路由。那么你可以在旁路由中安装小火箭等工具让你畅游资本主义网络，达到指定设备畅游的同时不影响家人使用的设备的目的。
使用nastool+pt+emby/jefflyfin/plex+qBittorrent/Transmission 打造一套完全属于自己的家庭观影中心，没有广告，不用会员，无删减，漂亮的海报墙。
xiaoya+rclone实现只需要消耗一点点阿里云盘的空间即可观看大几百T的电影、电视剧、动漫、综艺、体育、记录片等等。
xiaoya+Navidrome+音流实现消耗一点点阿里云盘空间收听几十万首歌曲。如果需要音乐资源得，可以关注我并给我发送消息音乐即可有2w多首得音乐资源分享给你。
使用广告屏蔽大师plus+使你指定设备屏蔽犯人得广告，让你得页面保持干爽。
安装Home Assistant让你所有得智能家居设备统一集成到一个平台中，小米、美的家居、aqara、苹果等等设备都集中到一个app中，最后还能通过HA再集成到apple home中，给主力手机是苹果得用户提供便利。
搭建一个LANraragi电子书、漫画平台，使你漫画、电子书自由。如果需要漫画资源，可以关注我并给我发送消息漫画即可。上述资源可以直接导入LANraragi中，不过漫画资源只有400G而且大多为老漫画，如圣斗士、全职猎人、浪客剑心等。
搭建一个碎片化得知识管理平台Memos，让你随时保存idea，和一些零碎得知识点。
搭建一个自己得密码管理器Vaultwarden，密码不再用浏览器保存，浏览器下载插件Vaultwarden可以自动填充自己保存过得账号密码，避免网站过多忘记密码。
搭建一个在线电视源的代理工具xteve，没有留iptv网线？机顶盒鸡肋，每月还要收费？这就是一个解决方案。
ddns-go,家宽很少有人会去办一个固定ip，那怎么办？打洞是一种方法。还有一种方案就是购买一个域名做动态代理，使用域名替代你随时变动得ip，随时随地访问家庭网络。
KMS服务器，需要激活windows、office?那么用它就没错了。
PhotoPrism相册管理，一款AI驱动的相册管理应用，手机照片太多又舍不得删？那就随时同步到服务器上，保证手机空间大小。
实时流量，监控各个设备流量上传下载情况。电视盒子的爱优腾又在偷偷跑pt了？让它无所遁形。
网心云，共享带宽，让你带宽回点本，不过不建议，容易被运营商封宽带。
ip限速，小孩又在偷偷看动画了?把他设备网速限了！
Heimdall，属于自己的导航面板，网址太多容易忘记，书签栏又不好看?那么这个就是为了解决这个问题的。
music tag,将没有歌词、没有封面的歌曲自动匹配并下载歌词封面等信息
minio+picGo,个人的图床应用+图片上传应用，储存个人博客所需的图片，想传多大传多大，想保存多久就保存多久，不用担心存在图床供应商图片丢失，图片过大限制上传等问题。
gitea, 私有的git server，不用担心传到github太慢或者gitee包含违禁词被删等问题。

程序员常用的一些小技巧

2024-04-10T03:40:00.000Z

[!NOTE] 一些小技巧
开发可以说是离不开github的，但是github常常打不开，是什么原因造成的？有什么方法解决？

为什么有些网站有时候能访问有时候又不可以？

其实很大概率是运营商的锅，运营商经常会对一些网站进行dns劫持和dns污染，最终就导致了这个问题。

如何解决

方法1 修改dns

对自己电脑的dns进行修改，使用全国通用的114.114.114.114或者谷歌的8.8.8.8

方法2 找到网站的ip并修改本地host

找到网站的ip

首先使用站长工具对你需要访问的网站进行ping测试，还是拿github来举例
https://ping.chinaz.com/

选一个国内的、不超时的、距离你位置比较近的、和你同一个运营商的
虽然下图都是一样的IP，但是很多其他同样原理的网站是不同的，所以加了很多限定词。

修改本地hosts

位置在C:/Windows/System32/drivers/etc
或者使用windows中比较好用的工具powerToys、switchHosts等工具修改
增加如下一行内容

ping所有的都不同，或者修改了也无法访问？

那可能就是被墙了，你需要特殊的方式来操作了🤓你懂的，不过有了那种方式上述方法也不太需要了。以上方式可以拓展一些场合，比如在路由器里面配置下确保刮削服务能连接商tmdb之类的。

记录一次对接海康安防平台做二次开发

2024-04-09T03:40:00.000Z

前几天对接了海康平台做二次开发，主要涉及到卡口车辆出入、人员刷脸或者刷卡进出等方面，做个记录

卡口相关

首先通过海康安防平台的api查询出入口的终端地址和父设备编号

海康接口调用

接口位置:http://{ip}:{port}/artemis-web/api/detail/1516237474282602496
接口名称: 获取停车库列表
接口url: api/resource/v1/park/parkList

调用一览

从这个接口中我们可以获取到父设备编号: parkIndexCode

通过父设备编号获取出入口列表

海康接口调用

接口位置: http://{ip}:{port}/artemis-web/api/detail/1516237474538455040
接口名称: 获取出入口列表
接口url: /api/resource/v1/entrance/entranceList

调用一览

这样可以讲获取到的code维护在自己数据库中待后面调用使用，卡口可分出入口，根据实际情况自己配置。

获取车道列表

海康接口调用

接口位置: http://{ip}:{port}/artemis-web/api/detail/1516237474626535424
接口名称: 获取车道列表
接口url: /api/resource/v1/roadway/roadwayList

调用一览

根据上一步获取到的entranceIndexCodes可以进一步获取到车道列表信息，同时保存其中的roadwayIndexCode以便后续的接口调用

安防平台对应

数据库设计，保存其中的出入口的左右车道编号以便后续记录并查询统计卡口车辆出入情况。

配置相应的服务接受海康推送的通行记录

海康的时间订阅

接口位置：http://{ip}:{port}/artemis-web/api/detail/1516237490963349504
接口名称：按事件类型订阅事件
接口url：/api/eventService/v1/eventSubscriptionByEventTypes

调用一览

通过此接口可以将自己服务接口注册进海康服务，最终海康服务会在有相关事件响应时将数据推送到我们服务接口中，可以选择性的将接口数据处理保存。

安防平台出入记录

人员相关

添加人员

海康接口调用

接口位置：http://{ip}:{port}/artemis-web/api/detail/1516237455638921216
接口名称：添加人员
接口url: /api/resource/v1/person/single/add

注意事项

添加人员可能会出现缺少tagId

需要进api管理的合作方进行tagId配置。

然后确保部署综合安防平台的人员将默认储存池配置起来

之后就可以正常添加人员信息和人员照片了，注意当前接口人员头像是必传的。

添加人员中的`orgIndexCode`

该字段需要进行下面操作后进行获取

添加园区及园区下企业

维护组织架构

首先需要对组织进行维护，组织名称和对应的组织编号，注意这边的组织编号实际上并没有太大用处，实际需要用到的是通过接口查询出来的orgIndexCode

获取`orgIndexCode`

接口位置：http://{ip}:{port}/artemis-web/api/detail/1516237457287282688
接口名称：根据父组织编号获取下级组织列表
接口url: /api/resource/v1/org/parentOrgIndexCode/subOrgList

调用一览

总节点的默认orgIndexCode固定为root000000

需要将其中每家企业的orgIndexCode储存下来，方便添加人员时使用。

本地储存表结构设计

create table hk_org  
(  
    id                    bigint auto_increment comment '主键ID'  
        primary key,  
    org_index_code        varchar(64)   null comment '组织唯一编码',  
    org_no                varchar(64)   null comment '组织自定义编码',  
    org_name              varchar(100)  null comment '组织名称',  
    org_path              varchar(1024) null comment '组织路径',  
    parent_org_index_code varchar(64)   null comment '父级组织(0标识为根组织)',  
    parent_org_name       varchar(64)   null comment '父级组织名称',  
    update_time           datetime      null comment '更新时间',  
    unit_id               bigint        not null comment '企业id'  
)  
    charset = utf8mb3  
    row_format = DYNAMIC;

导入后效果查看

安防平台可以分别导入人员信息和人员照片，照片按照姓名_身份证号.jpg多个一起压缩导入。这也是为什么有上一篇从文件服务器取流改名压缩文件的原因。

获取文件服务的文件并打包压缩至本地

2024-04-07T07:00:00.000Z

前言

当前项目有这样一个需求，mysql数据库中一张人员表存放了人员的照片路径，照片是集中存放在文件服务器上，当前项目文件服务器使用的是minio

表结构（供参考，只为了取值）

DROP TABLE IF EXISTS `cm_person`;
CREATE TABLE `cm_person`  (
  `person_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '人员ID',
  `unit_id` bigint(20) NOT NULL COMMENT '单位id',
  `depart_id` bigint(20) NULL DEFAULT NULL COMMENT '部门ID',
  `name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '姓名',
  `person_group` tinyint(2) NULL DEFAULT NULL COMMENT '组别',
  `code` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '人员编号',
  `tel` varchar(15) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '电话',
  `mobile` varchar(15) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '手机号',
  `sex` tinyint(1) NOT NULL COMMENT '性别',
  `birth_date` date NULL DEFAULT NULL COMMENT '出生日期',
  `address` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '地址',
  `id_card` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '身份证号',
  `photo_url` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '照片路径',
  `remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',
  `nation` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '民族',
  `native_place` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '籍贯',
  `school` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '最后毕业的学校',
  `major` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '专业',
  `qualifications` tinyint(2) NULL DEFAULT NULL COMMENT '1：大专及以下  2：本科  3：硕士 4：博士',
  `degree` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '最高学位',
  `political_belief` tinyint(2) NULL DEFAULT NULL COMMENT '政治面貌(\'1：中共党员 2：中共预备党员 3：共青团员  4：民革党员  5：民盟盟员  6：民建会员   7：民进会员  8：农工党党员   9：致公党党员  10：九三学社社员  11：台盟盟员 12：无党派人士  13：群众)',
  `post_id` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '职务',
  `safe_role` tinyint(255) NOT NULL DEFAULT 0 COMMENT '人员在企业中的安全角色 1：分管领导、3：安全总监、4：安全管理部门负责人、5：车间主任、6：安全管理人员、7：特种作业人员、9. 主要负责人',
  `hiredate` date NULL DEFAULT NULL COMMENT '入职时间',
  `work_experience` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '工作经历',
  `person_type` tinyint(2) NULL DEFAULT NULL COMMENT '1；外协员工\r\n2：临时人员\r\n3：员工',
  `del_flg` tinyint(2) NOT NULL COMMENT '0：正常 1逻辑删除',
  `create_id` bigint(20) NOT NULL COMMENT '创建人id',
  `create_time` datetime(0) NOT NULL COMMENT '创建时间',
  `update_id` bigint(20) NOT NULL COMMENT '更新人id',
  `update_time` datetime(0) NOT NULL COMMENT '更新时间',
  `hk_person_id` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '海康平台人员id',
  `hk_person_code` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '海康平台卡号',
  `is_apply` tinyint(1) NULL DEFAULT 0 COMMENT '是否为申请人1：是    0：否',
  `synchronization_status` tinyint(2) NULL DEFAULT NULL COMMENT '同步状态 0：否 1：是',
  `flag` tinyint(1) NULL DEFAULT NULL COMMENT '正常0   无照片1   未开卡2    ',
  `hk_face_id` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '海康平台人脸ID',
  `hk_handle_status` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '0:无人脸数据 1:增加人脸 2：修改人脸',
  PRIMARY KEY (`person_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5581 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '公共-企业人员信息' ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

工具说明

代码中主要使用了如下工具

HikariCP数据库连接池
mybatis plus持久层框架
minio文件服务器，使用了allbs-oss自开发的支持S3协议的操作工具

源码地址

https://github.com/chenqi92/photo-tool.git

源码说明

使用`allbs-oss`文件操作工具连接minio文件服务器

oss:
  # 连接地址，因为我在host中配置了pc-server的ip所以这边直接用字符串即可
  endpoint: http://pc-server:9000
  # 地区
  region: us-west-rack-2
  # minio账号
  access-key: minio
  # minio密码
  secret-key: 123456
  # 文件服务器上默认的储存桶，用于区分项目时使用，可为空
  bucket-name:

application添加注解`@EnableAllbsOss`启用该工具

创建一个项目启动即可执行的类

实现CommandLineRunner即可

@Slf4j
@Component
public class DownAllPhoto implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        
    }
}

查询数据库中想要的人员数据，并转为以姓名_身份证号的形式下载后打包至D盘中

package cn.allbs.phototool.task;

import cn.allbs.oss.service.OssTemplate;
import cn.allbs.phototool.entity.cm.CmPersonEntity;
import cn.allbs.phototool.service.cm.CmPersonService;
import com.amazonaws.services.s3.model.S3Object;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * 类 DownAllPhoto
 *
 * @author ChenQi
 * @date 2024/4/7
 */
@Slf4j
@Component
public class DownAllPhoto implements CommandLineRunner {

    @Resource
    private CmPersonService cmPersonService;

    @Resource
    private OssTemplate ossTemplate;

    @Override
    public void run(String... args) throws Exception {
        // 查询人员相关信息
        List persons = cmPersonService.list(Wrappers.query().lambda().isNull(CmPersonEntity::getHkPersonId).and(i -> i.isNotNull(CmPersonEntity::getPhotoUrl).or().isNotNull(CmPersonEntity::getPhotoUrl)));
        log.info("当前查询到人员总数:{}", persons.size());
        // 创建一个文件夹来保存图片
        Path dirPath = Paths.get("tempImages");
        if (!Files.exists(dirPath)) {
            try {
                Files.createDirectory(dirPath);
            } catch (IOException e) {
                log.error("创建文件夹失败", e);
                return;
            }
        }
        // 获取文件服务器中的文件
        persons.forEach(person -> {
            try (S3Object s3Object = ossTemplate.getObject("pcfiles", person.getPhotoUrl())) {
                InputStream inputStream = s3Object.getObjectContent();
                String fileName = person.getName() + "_" + person.getIdCard() + ".jpg";
                log.info("下载文件:{}", fileName);
                Path outputPath = dirPath.resolve(fileName);
                Files.copy(inputStream, outputPath, StandardCopyOption.REPLACE_EXISTING);
            } catch (Exception e) {
                log.error("文件下载失败", e);
            }
        });
        // 创建一个ZIP文件
        Path zipPath = Paths.get("D:\\images.zip");
        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipPath.toFile()))) {
            Files.walk(dirPath).filter(path -> !Files.isDirectory(path)).forEach(path -> {
                ZipEntry zipEntry = new ZipEntry(dirPath.relativize(path).toString());
                try {
                    zos.putNextEntry(zipEntry);
                    Files.copy(path, zos);
                    zos.closeEntry();
                } catch (IOException e) {
                    log.error("添加文件到ZIP失败", e);
                }
            });
        } catch (IOException e) {
            log.error("创建ZIP文件失败", e);
        }
    }
}

实现效果

使用ai创作歌曲

2024-03-26T07:41:00.000Z

使用ChatGPT生成歌词

模板为:

你是歌词大师，请你帮我写一段xx得歌词，描述的是xxx的故事，整体歌曲时长3分钟以内，歌词要押韵，副歌部分要进行重复。请按以下结构帮我创作：[instrumental intro][Verse 1] <歌词>[Chorus] <歌词>[Verse 2] <歌词>[Chorus] <歌词>[Bridge] <歌词>[Guitar solo][Chorus] <歌词>[Outro][End]

使用Suno ai生成对应得歌曲

下载歌曲

软考资料收集与分享

2024-03-26T00:41:00.000Z

报名地址

https://bm.ruankao.org.cn/sign/welcome

资料分享

中级

软件评测师

https://www.alipan.com/s/K9aooh1DVSg

软件设计师

https://www.alipan.com/s/25rom42VEVw

软件过程能力评估师

计算机辅助设计师

电子商务设计师

https://www.alipan.com/s/KHzdWa5Rtqs

系统集成项目管理工程师

https://www.alipan.com/s/YPjeXXPoTi1

信息系统监理师

https://www.alipan.com/s/XCkc8K59BZq

信息安全工程师

https://www.alipan.com/s/NHJKvCn8LxX

数据库系统工程师

https://www.alipan.com/s/NNDfFDGLF6B

信息系统管理工程师

https://www.alipan.com/s/KvYtHVSSeSh

计算机硬件工程师

信息技术支持工程师

高级

信息系统项目管理师

https://www.alipan.com/s/Y5EzTSWM9nT

系统分析师

https://www.alipan.com/s/DbtJvB6DbcL

系统架构设计师

https://www.alipan.com/s/ek4sGwrEqeh

网络规划设计师

https://www.alipan.com/s/EAKYwQ4p9Mg

系统规划与管理师

Chrome浏览器同步书签到个人github中

2024-03-22T09:57:00.000Z

同步浏览器数据

下载插件

生成github个人账号的token

点击头像->点击Settings

拉到最下方点击Developer settings

点击Tokens

生成一个新的token

授权并配置永不过期

配置插件

Username就是github的登录用户名

Access Token就是刚才申请的token

path可以固定为chome-bookmark/bookmark.json

Remember Me开关可以打开

使用

在需要同步上传的机器的浏览器点击Upload

在新机器配置好参数后点击Download即可

vue纯前端导出excel

2023-10-17T07:00:00.000Z

提供数据

从后端获取list数据或者前端定义list数据。

引用包

"dependencies": {
    "file-saver": "^2.0.1",
    "xlsx-style": "^0.8.13",
}

导出

分别定义表格中展示的名称和list中对应的字段

const tHeader = [
        "登录名",
        "姓名",
        "手机号码",
        "邮箱",
        "状态",
        "类型",
        "机构名称",
        "更新时间"
];
const filterVal = [
    "userName",
    "realName",
    "mobile",
    "email",
    "statusDesc",
    "typeDesc",
    "tierName",
    "createTime"
];

获取list数据

略。包含定义的字段即可

导出实现

1	downloadExcel("导出数据", tHeader, filterVal, list, () => {});

导出方法

export function downloadExcel(filename, colNameList, colKeyList, list, callback, sheetName) {
  const autoWidth = true
  const bookType = 'xlsx'
  import('@/vendor/Export2Excel').then(excel => {
    const tHeader = colNameList
    const filterVal = colKeyList
    const data = formatJson(filterVal, list)
    filename = (filename != null && filename != '') ? filename : 'excel'
    excel.export_json_to_excel({
      header: tHeader,
      data,
      filename: filename,
      autoWidth: autoWidth,
      bookType: bookType,
      sheetName: sheetName
    })
    if (callback != null && callback != undefined) {
      callback()
    }
  })
}

function formatJson(filterVal, jsonData) {
  const data = []
  for (let i = 0; i < jsonData.length; i++) {
    const row = jsonData[i]
    const val = []
    for (let j = 0; j < filterVal.length; j++) {
      val.push(row[filterVal[j]])
    }
    data.push(val)
  }
  return data
}

Export2Excel

/* eslint-disable */
import { saveAs } from 'file-saver'
import XLSX from "xlsx-style"
// import XLSX from 'xlsx'
// import XLSX from "xlsx-style"


function generateArray(table) {
  var out = [];
  var rows = table.querySelectorAll('tr');
  var ranges = [];
  for (var R = 0; R < rows.length; ++R) {
    var outRow = [];
    var row = rows[R];
    var columns = row.querySelectorAll('td');
    for (var C = 0; C < columns.length; ++C) {
      var cell = columns[C];
      var colspan = cell.getAttribute('colspan');
      var rowspan = cell.getAttribute('rowspan');
      var cellValue = cell.innerText;
      if (cellValue !== "" && cellValue == +cellValue) cellValue = +cellValue;

      //Skip ranges
      ranges.forEach(function (range) {
        if (R >= range.s.r && R <= range.e.r && outRow.length >= range.s.c && outRow.length <= range.e.c) {
          for (var i = 0; i <= range.e.c - range.s.c; ++i) outRow.push(null);
        }
      });

      //Handle Row Span
      if (rowspan || colspan) {
        rowspan = rowspan || 1;
        colspan = colspan || 1;
        ranges.push({
          s: {
            r: R,
            c: outRow.length
          },
          e: {
            r: R + rowspan - 1,
            c: outRow.length + colspan - 1
          }
        });
      };

      //Handle Value
      outRow.push(cellValue !== "" ? cellValue : null);

      //Handle Colspan
      if (colspan)
        for (var k = 0; k < colspan - 1; ++k) outRow.push(null);
    }
    out.push(outRow);
  }
  return [out, ranges];
};

function datenum(v, date1904) {
  if (date1904) v += 1462;
  var epoch = Date.parse(v);
  return (epoch - new Date(Date.UTC(1899, 11, 30))) / (24 * 60 * 60 * 1000);
}

function sheet_from_array_of_arrays(data, opts) {
  var ws = {};
  var range = {
    s: {
      c: 10000000,
      r: 10000000
    },
    e: {
      c: 0,
      r: 0
    }
  };
  for (var R = 0; R != data.length; ++R) {
    for (var C = 0; C != data[R].length; ++C) {
      if (range.s.r > R) range.s.r = R;
      if (range.s.c > C) range.s.c = C;
      if (range.e.r < R) range.e.r = R;
      if (range.e.c < C) range.e.c = C;
      var cell = {
        v: data[R][C]
      };
      if (cell.v == null) continue;
      var cell_ref = XLSX.utils.encode_cell({
        c: C,
        r: R
      });

      if (typeof cell.v === 'number') cell.t = 'n';
      else if (typeof cell.v === 'boolean') cell.t = 'b';
      else if (cell.v instanceof Date) {
        cell.t = 'n';
        cell.z = XLSX.SSF._table[14];
        cell.v = datenum(cell.v);
      } else cell.t = 's';

      ws[cell_ref] = cell;
    }
  }
  if (range.s.c < 10000000) ws['!ref'] = XLSX.utils.encode_range(range);
  return ws;
}

function Workbook() {
  if (!(this instanceof Workbook)) return new Workbook();
  this.SheetNames = [];
  this.Sheets = {};
}

function s2ab(s) {
  var buf = new ArrayBuffer(s.length);
  var view = new Uint8Array(buf);
  for (var i = 0; i != s.length; ++i) view[i] = s.charCodeAt(i) & 0xFF;
  return buf;
}

export function export_table_to_excel(id) {
  var theTable = document.getElementById(id);
  var oo = generateArray(theTable);
  var ranges = oo[1];

  /* original data */
  var data = oo[0];
  var ws_name = "Sheet1";

  var wb = new Workbook(),
    ws = sheet_from_array_of_arrays(data);

  /* add ranges to worksheet */
  // ws['!cols'] = ['apple', 'banan'];
  ws['!merges'] = ranges;

  /* add worksheet to workbook */
  wb.SheetNames.push(ws_name);
  wb.Sheets[ws_name] = ws;

  var wbout = XLSX.write(wb, {
    bookType: 'xlsx',
    bookSST: false,
    type: 'binary'
  });

  saveAs(new Blob([s2ab(wbout)], {
    type: "application/octet-stream"
  }), "test.xlsx")
}

export function export_json_to_excel_multi({
  dataArray,
  filename,
  merges = [],
  autoWidth = true,
  bookType = 'xlsx'
} = {}) {
  /* original data */
  filename = filename || 'excel-list'
  // var dataArray = [{header, data, sheetName}]

  let finalDataArr = []
  let wb = new Workbook();
  if (dataArray != null && dataArray != []) {
    for (let i = 0; i < dataArray.length; i++) {
      let data = [...dataArray[i].data]

      let topHeader = []
      for (let km = 0; km < dataArray[i].header.length; km++) {
        if (km==0) {
          topHeader.push(dataArray[i].sheetName)
        } else {
          topHeader.push("")
        }
      }
      data.unshift(dataArray[i].header);
      data.unshift(topHeader);
      let start = getColumnNameFromIdNotAdd([1, 0])
      let end = getColumnNameFromIdNotAdd([1, dataArray[i].header.length -1])

      merges = [start + ":" + end];
/*      for (let j = dataArray[i].multiHeader.length - 1; j > -1; j--) {
        data.unshift(dataArray[i].multiHeader[j])
      }*/
      finalDataArr.push(data)

      let ws_name = dataArray[i].sheetName;

      let ws = sheet_from_array_of_arrays(data);

      if (merges.length > 0) {
        if (!ws['!merges']) ws['!merges'] = [];
        merges.forEach(item => {
          ws['!merges'].push(XLSX.utils.decode_range(item))
        })
      }

      if (autoWidth) {
        /*设置worksheet每列的最大宽度*/
        const colWidth = data.map(row => row.map(val => {
          /*先判断是否为null/undefined*/
          if (val == null) {
            return {
              'wch': 10
            };
          }
          /*再判断是否为中文*/
          else if (val.toString().charCodeAt(0) > 255) {
            return {
              'wch': val.toString().length * 2
            };
          } else {
            return {
              'wch': val.toString().length
            };
          }
        }))
        /*以第一行为初始值*/
        let result = colWidth[0];
        for (let i = 1; i < colWidth.length; i++) {
          for (let j = 0; j < colWidth[i].length; j++) {
            if (result[j]['wch'] < colWidth[i][j]['wch']) {
              result[j]['wch'] = colWidth[i][j]['wch'];
            }
          }
        }
        ws['!cols'] = result;
      }

      /* add worksheet to workbook */
      wb.SheetNames.push(ws_name);
      wb.Sheets[ws_name] = ws;
      //excel标题样式
      let dataInfo = wb.Sheets[ws_name];


      let overCells = []
      let overPosArr = dataArray[i].overPosArr
      if (overPosArr != null && overPosArr != undefined && overPosArr != '') {
        for (let n = 0; n < overPosArr.length; n++) {
          overCells.push(getColumnNameFromId(overPosArr[n]))
        }
      }
      for (let m in dataInfo) {
        if (m == "!ref" || m == "!merges" || m == "!cols" || m == "!rows") { } else {
          let num = getNum(m+"");
          if (num != null && num != undefined && num == 1) {
            dataInfo[m + ""].s = getHeaderStyle();
          }
          if (overCells.indexOf(m + "") >= 0) {
            dataInfo[m + ""].s = getOverStyle();
          }
        }
      }
     /* for (let m = 0; m < dataArray[i].header.length; m++) {
        dataInfo[arr[i]].s = style;
      }*/
    }
    let wbout = XLSX.write(wb, {
      bookType: bookType,
      bookSST: false,
      type: 'binary'
    });
    saveAs(new Blob([s2ab(wbout)], {
      type: "application/octet-stream"
    }), `${filename}.${bookType}`);
  }

  /*data = [...data]
  data.unshift(header);

  for (let i = multiHeader.length - 1; i > -1; i--) {
    data.unshift(multiHeader[i])
  }*/




}

function getNum(str) {

  let numArr = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'];
  let num
 if (str != null && str != '') {
   for (let i = 0; i < str.length; i++) {
     if (numArr.indexOf(str[i]) >= 0) {
      num = str.substring(i)
       return num
     }
   }
 }
}

function getHeaderStyle() {
  const borderAll = {
    top: {
      style: "thin"
    },
    bottom: {
      style: "thin"
    },
    left: {
      style: "thin"
    },
    right: {
      style: "thin"
    }
  };
  let style = {
    // border: borderAll,
    font: {
      // name: "宋体",
      // sz: 18,
      color: { rgb: "000000" },
      bold: true,
      // italic: false,
      // underline: false
    },
    alignment: {
      horizontal: "center",
      vertical: "center"
    }

    // fill: {
    //   fgColor: {rgb: "008000"},
    // },
  };
  return style
}


function getOverStyle() {
  let style = {
    font: {
      // name: "宋体",
      // sz: 18,
      color: { rgb: "FF0000" },
      bold: false,
    }
  };
  return style
}

export function export_json_to_excel({
                                       multiHeader = [],
                                       header,
                                       data,
                                       filename,
                                       merges = [],
                                       autoWidth = true,
                                       bookType = 'xlsx'
                                     } = {}) {
  /* original data */
  filename = filename || 'excel-list'
  data = [...data]
  for (let i = multiHeader.length - 1; i > -1; i--) {
    data.unshift(multiHeader[i])
  }
  data.unshift(header);

  var ws_name = "Sheet1";
  var wb = new Workbook(),
    ws = sheet_from_array_of_arrays(data);

  if (merges.length > 0) {
    if (!ws['!merges']) ws['!merges'] = [];
    merges.forEach(item => {
      ws['!merges'].push(XLSX.utils.decode_range(item))
    })
  }

  if (autoWidth) {
    /*设置worksheet每列的最大宽度*/
    const colWidth = data.map(row => row.map(val => {
      /*先判断是否为null/undefined*/
      if (val == null) {
        return {
          'wch': 10
        };
      }
      /*再判断是否为中文*/
      else if (val.toString().charCodeAt(0) > 255) {
        return {
          'wch': val.toString().length * 2
        };
      } else {
        return {
          'wch': val.toString().length
        };
      }
    }))
    /*以第一行为初始值*/
    let result = colWidth[0];
    for (let i = 1; i < colWidth.length; i++) {
      for (let j = 0; j < colWidth[i].length; j++) {
        if (result[j]['wch'] < colWidth[i][j]['wch']) {
          result[j]['wch'] = colWidth[i][j]['wch'];
        }
      }
    }
    ws['!cols'] = result;
  }

  /* add worksheet to workbook */
  wb.SheetNames.push(ws_name);
  wb.Sheets[ws_name] = ws;

  var wbout = XLSX.write(wb, {
    bookType: bookType,
    bookSST: false,
    type: 'binary'
  });
  saveAs(new Blob([s2ab(wbout)], {
    type: "application/octet-stream"
  }), `${filename}.${bookType}`);
}


/**
 * 根据坐标获取列名
 * @param {Object} cellId
 */
function getColumnNameFromId(cellId){
  if (! Array.isArray(cellId)) {
    cellId = cellId.split('-');
  }
  var i = cellId[1];
  var letter = '';
  if (i > 701) {
    letter += String.fromCharCode(64 + parseInt(i / 676));
    letter += String.fromCharCode(64 + parseInt((i % 676) / 26));
  } else if (i > 25) {
    letter += String.fromCharCode(64 + parseInt(i / 26));
  }
  letter += String.fromCharCode(65 + (i % 26));
  return letter + (parseInt(cellId[0]) + 3);
}


/**
 * 根据坐标获取列名
 * @param {Object} cellId
 */
function getColumnNameFromIdNotAdd(cellId){
  if (! Array.isArray(cellId)) {
    cellId = cellId.split('-');
  }
  var i = cellId[1];
  var letter = '';
  if (i > 701) {
    letter += String.fromCharCode(64 + parseInt(i / 676));
    letter += String.fromCharCode(64 + parseInt((i % 676) / 26));
  } else if (i > 25) {
    letter += String.fromCharCode(64 + parseInt(i / 26));
  }
  letter += String.fromCharCode(65 + (i % 26));
  return letter + (parseInt(cellId[0]));
}

摆脱爱优腾，使用Emby/jellyfin+nastool+pt打造一套完整的家庭影音系统

2023-08-24T07:13:00.000Z

Emby（媒体服务器）

媒体服务器，付费解锁硬件解码等功能，终身800多。可以直接使用jellyfin，jellyfin为emby收费后脱离出来的完全免费版本。

我的设备是群晖可以直接从套件中安装也可以使用docker安装。

Emby的电影刮削(就是获取指定视频的海报、演员照片姓名、评分之类的)还是不错的，电视剧的需要科学，科学后效果也一般。相反jellyfin因为可以装豆瓣插件，效果都挺不错的，但是太吃cpu了。

套件安装

但是emby套件安装的实际使用过程中效率极慢，所以我最后还是选择在软路由中使用docker装了一个。

docker安装

docker安装的配置如下，需要配置的内容不多，主要是红框内容。

配置完正常启动即可。

emby配置

打开地址:http://{安装设备ip}:8096。默认端口是8096，但是和jellyfin端口冲突，所以实际可能不是8096，自己注意下即可。

创建用户之后正常进入系统。

这是我个人的配置后展示的画面。

设置媒体库

大体分为电视剧和动漫两类，动漫视为电视剧。下面是电影和电视剧添加至媒体库的配置，动漫和电视剧的一致，文件夹根据自己实际情况来选。但是记得文件夹需要给权限，如果是套件安装有个Emby用户将其设置到你放视频的地方即可。如果是docker安装需要设置read和write权限，UID和GID设置为0。

电视剧

电影

jellyfin(媒体服务器)

如果是群晖docker记得换源或者将系统升级到7.2+不然docker源用不起来，被墙了。

下载映像

配置服务

我这边网络设置的是host所以端口设置为空，如果设置为bridge的话需要设置一下端口映射。

储存空间和环境变量设置如下，储存空间三个文件夹需要根据你自己服务器上的路径来设置，主要就是缓存的cache、配置文件config、媒体文件video三个目录。

启动即可。

媒体库配置和emby差不多

配置豆瓣刮削

储存库URL可以直接使用我的这个https://nas.allbs.cn:8888/cloudpic/2023/08/f99ad9b5e94f0c89f59b4c01632d85aa.json或者自己放浏览器下载后放到自己指定的位置。毕竟有可能出现我的minio忘记启动导致无法使用的情况。

qBittorrent(下载器)

也可使用Transmission，当差不差。

映像下载

docker配置

还是一样的网络设置host即可，如果要设置桥接，记得配置端口映射。

主要就是两个目录一个是配置文件的目录，还有一个就是下载视频之后储存的位置。我这边不直接放到video中而是放到/video/download中，主要是为了后面可以直接使用硬链接，不直接转移视频，这样视频不会乱七八糟的存放的同时也可以保种。

服务配置

这里劝告各位还是需要设置一下账号密码的，之前看一哥们用的ipv6又没设置密码直接挂在google搜索的第三。。。心真大。。。

nastool(媒体管理工具)

docker下载配置

docker配置

因为我这边使用了桥接，所以有个端口映射。

这里主要是三个目录需要配置，一个放nastool配置文件的目录，一个是视频存放目录，一个是下载的目录。

nastool配置

最新版本需要PT账号认证，需要自备PT站的账号密码。可以找不需要认证的docker版本。

这种平台还是比较多的，比如馒头，1ptba等等

pt站配置

cookie可以按F12开发者模式随便找个请求拿其中的cookie即可。

注册TMDB并获取其中的api key

将红箭头的内容拷贝到TMDB API key中即可，后面的openAi api key可以不填，有chatgpt的api可以申请后获取填入。

媒体库目录

设置自己nas上的储存目录即可。

目录同步

根据自己目录配置即可，源目录是下载的目录，目的目录是上面emby/jellyfin配置的媒体库目录，使用硬链接同步，可以自动管理文件。

过滤规则

过滤规则是将自己优先相看的视频类型排序，比如想看4K或者蓝光就将对应的内容调整到前面，搜索的时候会根据这个规则来排序

索引器

索引器很关键，不能忘记勾选，否则上面搜索视频的时候将不会在非勾选的站点搜索。

下载器

配置你自己使用的下载器即可，需要设置账号密码。

媒体服务器

根据自己使用的媒体服务器类型配置，需要在媒体服务器上先生成api key

插件

根据自己需要下载插件，比如需要目录自动同步

emby/jellyfin/infuse（播放器）

emby

播放器下载地址：https://emby.media/download.html

jellyfin

播放器下载地址: https://jellyfin.org/downloads/clients/all/

https://github.com/jellyfin/jellyfin-media-player/releases

infuse

如果是苹果全家桶使用这个软件也挺不错，自带解码，适合没有GPU的机器，订阅也不贵一年68。

vidHub

国产产品，不支持杜比，作者已开启收割模式，不过价格倒是不贵。

搭建自托管的密码管理器

2023-07-27T03:14:00.000Z

说明

秘钥管理的工具挺多的，但是个人感觉最好用的还是收费的1password和可以自建服务的bitwarden。1password体验还是不错的，但是有点贵了。所以下方使用bitwarden来搭建。docker hub被墙问题通过升级群晖系统至7.2+来解决或者添加国内镜像源。

使用docker下载镜像

下载这个社区重构的Rust版本，避免官方全家桶的超高占用。

配置参数启动参数和端口

端口主要是下面那个80的端口映射，后面需要使用这个端口访问管理web

环境变量配置一下两项

1 2	SIGNUPS_ALLOWED true TZ Asia/Shanghai

一直下一步启动即可

访问web管理端

浏览器输入:http://群晖ip:3088

因为需要https才能完成配置，所以按照上几篇文章的说明来配置https即可。流程是一样的，设置反向代理服务器和路由器端口映射。

创建账户

点击下方的创建账号创建个人账户完成之后，记得把SIGNUPS_ALLOWED设置为false重启一下。

浏览器中的使用

直接在商店下载该插件即可

配置自托管服务器

点击区域选择自托管之后输入上方配置好的服务端域名，然后使用上面创建的账户密码登录即可。

git私有仓库搭建

2023-07-26T06:14:00.000Z

前言

gitlab内存占用太高，所以用了比较节省资源的gitea

条件

因为众所周知的原因，大家都知道docker hub被墙了，所以如果在群晖nas中使用docker，要么是将镜像修改为国内的镜像，要么将群晖的DSM升级到7.2+，原来的docker套件会升级为Container Manager，可以正常使用docker下载各种镜像。

安装数据库

gitea需要依赖数据库，这里以mysql做示例

双机运行镜像

配置端口和文件夹如下图

注意初始化的文件夹必须为空，否则初始化目录会失败导致容器启动失败。

环境变量配置root用户密码和插件密码

将MYSQL_ROOT_PASSWORD和MYSQL_AUTHENTICATION_PLUGIN配置进去，下图的两个汉字密码修改为你自己需要设定的密码即可。

后续不需要其他配置直接下一步后完成即可

使用连接工具连接上mysql并创建库`gitea`

比如我使用的是navicat，新建连接，主机填群晖的内网ip，密码就是上一步在环境变量中配置的密码。

新建数据库，库名gitea，字符集和排序规则都是utf8

安装gitea

双机映像运行即可

配置端口和数据储存的文件夹

因为我本地端口和gitea默认的端口有冲突，所以修改成了4022和43000。

运行

上述配置好后直接下一步然后点击完成即可

访问gitea web端进行数据库配置

访问地址: 群晖主机ip:上述配置的端口。以我自己环境说明，我群晖内网ip为192.168.0.150，上述配置的端口为43000，所以访问地址为http://192.168.0.150:3001/

访问页面如图所示，将第一步运行的数据库配置进来。数据库主机如果mysql和gitea都为桥接则设置为群晖ip:3306。如果都为host则设置localhost:3306

最下方可以设置管理员的账号密码，如果不设置则第一个注册的用户就是管理员。

等待安装完成，正常情况下几秒应该就装好跳转到首页了

映射至公网访问

首先映射到公网需要必要条件是公网ip(隔几天会变的那玩意,不是固定的,电信的话打个电话找人工不要一分钟就有了)，有一个固定的域名可以ddns。具体做法可以看前几篇文章。

先配置登陆门户->反向代理服务器

然后在路由器里面配置好端口转发即可

然后就可以正常访问了

群晖NAS搭建VPN Server，使自己能够访问内网服务

2023-07-11T09:25:00.000Z

下载套件

套件中心VPN Server已下架所以需要在官网上下载后安装。

下载地址

配置VPN

设置权限

配置可以使用VPN的用户

开始配置

这边我使用的是L2TP/IPSec的方式,设置预共享秘钥并记住。点击应用开启即可。

windows

配置window访问在网络和internet-> VPN-> 添加VPN

配置好了之后可能无法访问，因为需要设置一下windows

使用管理员权限打开cmd之后粘贴以下两行代码（分两次输入执行）之后重启电脑即可。

1
2
3

REG ADD HKLM\SYSTEM\CurrentControlSet\Services\PolicyAgent /v AssumeUDPEncapsulationContextOnSendRule /t REG_DWORD /d 0x2 /f

REG ADD HKLM\SYSTEM\CurrentControlSet\Services\RasMan\Parameters /v ProhibitIpSec /t REG_DWORD /d 0x0 /f

手机端，手上没有安卓但是原理一致

设置-> VPN

点击完成后启用即可

个人文档图床搭建使用

2023-07-10T03:25:00.000Z

准备条件

使用工具	说明
群晖nas	家用服务器，无论白群黑群，用是一样的
路由器	需要在路由器中配置群晖nas作为DMZ主机，或者开放群晖nas指定端口
公网或ipv6	为了能在公网中访问群晖nas
域名	非必须，主要是比较好用，用其他方式比如内网穿透等方式也可以

群晖nas

之前用的一台DS218+，升级了内存至6g，最近趁着搬家和618置换了一台923+并升级了32g，两块2T硬盘也置换了4块4T。所以需要把之前服务器内数据同步到新的里面。

路由器

这个不用说，肯定要在路由器中设置外网端口并映射到群晖nas。要么是直接将群晖作为DMZ，要么就是做端口映射。

公网ip或ipv6

个人在江苏，办理了两个宽带都是电信的，要公网ip还是比较简单的。直接打10000找人工跟她说要公网ip，基本都是秒答应，然后光猫关机十分钟就可以了。

注意：是公网ip而不是固定ip，固定ip还是挺贵的，公网ip是免费的。

光猫需要修改桥接模式，这个直接找办理宽带的师傅远程修改下就可以了，当然自己有超管账号也可以自己修改，注意改完后记得重启光猫并根据改完后的宽带账号密码设置路由器拨号上网。

域名

这个不是必须的，但是有了还是挺方便的，也不贵一年几十块。

群晖nas安装minio作为文件服务器

安装套件中心

大家都知道国内已经屏蔽docker hub，所以群辉nas中自带的docker套件肯定也查不到相关的镜像了，但是*DSM升级7.2+*之后会将以前的docker套件升级为Container Manager,还是可以像以前一样使用的。

打开container manager并安装minio

在映像中找到minio并运行

常规设置开启自动启动

高级设置

端口配置

首先需要两个端口一个作为minio控制台的端口，一个作为minio api服务的端口

上面的9000是minio api使用的端口，下面8000是minio控制台使用的端口。如果需要修改，则根据这篇文章后续的启动命令中启动参数。

储存空间设置，配置一个config配置文件目录，配置一个文件储存目录。

下面这个/data目录要和下方的启动命令相对应

设置管理员账号密码

在环境中点击新增增加两行分别用来配置账号MINIO_ROOT_USER和密码MINIO_ROOT_PASSWORD

网络

网络可以设置和nas同一个网络环境，当然使用桥接也可以。

启动命令

根据上述端口配置来确定启动命令

比如上方设置的控制台端口8000,api端口为9000,文件基础目录为/data,则启动命令为server --address 0.0.0.0:9000 --console-address 0.0.0.0:8000 /data,可以根据自己实际使用情况自行修改。

运行容器

配置minio外网访问

群晖nas中代理端口

打开控制面板-> 登录门户-> 高级-> 反向代理服务器配置控制台端口和api端口的代理

配置端口

来源

协议:选择https是因为我的域名申请了ssl证书，如果没有设置则使用http
主机名: 使用*号即可
端口: 我这边设置的是8000,那么最后我从外网使用域名访问的时候就是https://域名:8000, 可以修改其他端口

目的地

协议: 选http即可
主机名: 因为上方网络选择的是host所以这边直接使用localhost就可以了
端口: 这边的端口要和上面启动命令中设置的端口一致

我这边自定义了外网访问端口，实际效果如下

minio配置

先使用上述的域名+反代端口访问控制台，账号密码就是环境中配置的那俩。

创建桶

设置桶Access Policy为Public

创建应用id和秘钥用于上传图片，而避免使用自己的超管账号，记住生成的accessKey和Secret key，后面图床配置会用到

下载配置图床工具

说明

有挺多类似的工具，比如picGp，mac上的uPic等

我这边使用picGo来说明

下载

点击右侧release并找到打包好的包，根据自己使用平台下载指定的版本

picGo配置

打开picGo并找到S3协议勾选

在图床设置里面配置S3协议

应用秘钥: 上面在minio控制端Access keys刚生成的Access Key
应用秘钥: 上面在minio控制端Access keys刚生成的Secret Key
桶: 就是刚才在minio控制台中创建的桶的名称
文件路径: 这个用于重命名上传图片的名称，避免出现重复，我这边使用的是年月加md5命名，所以最后设置是{year}/{month}/{md5}.{extName}

最后点击确定并设置默认图床即可正常使用了，可以在PicGo设置中配置上传后自动复制文件名

软件可能出现的bug

之前使用时碰到过一次图片无法上传，相册无法显示的问题，具体解决办法是找到C:\Users\ChenQi\AppData\Roaming\picgo目录下的picgo.db备份后删除，重启picGo客户端即可正常使用，但是会造成相册情况。

在Typora中写文档时粘贴图片自动上传。

在偏好设置-> 图像中配置即可，这样在粘贴图片时即可自动上传图片了

装修踩坑和心得

2023-06-13T04:23:00.000Z

前期准备

✅ 装修公司会让你先交定金再进行设计，能不交就不交，毕竟装修公司到处都是。

✅ 选择能够将装修清单带出去的公司，部门公司会说只有内网能看，这种的不建议。

✅ 装修清单里面的工艺要标清楚，那种一句话的不能选，后期会涉及大量增项。

✅ 最好还是找个懂行的监理，监理意义在于施工前和工人对接工艺，工艺对接好验收也简单。

✅ 装修公司的合同一般是当地标准合同的简化版，千万要增加延期交付的违约金，比如可以定个超过一天200+。

✅ 不要和项目经理签项目延期单，延期就罚钱。

✅ 项目支付比例一般分四次，进场前20~30%，水电结束30%，木瓦结束30%，验收5%，千万记得要留个5%的项目保证金，要写在合同上，一年后没问题再支付，不然你钱交完，装修公司是不上心的。

✅ 规定好装修公司的验收标准必须满足国标的验收标准和环保标准，额外写在合同上！

✅ 让装修公司确定好项目经理，对接好所有的施工标准，如果能接受再签合同，不然会出现扯皮。

✅ 设计师给的设计图并不一定具备施工条件，比如设计师为了好看可能会改雨水管、拆顶梁等。实际看过现场之后让设计师重新修改方案。

🧑‍💻 这是监理给的一份工艺最低要求可以参考:

施工阶段

打拆砌墙

❗ 和物业确定好哪些墙能拆哪些不能拆，千万不要拆承重墙！一般开发商给的户型图上标黑色的那部分就是承重墙。

👨‍🔧 打拆工人一般是将建筑垃圾放在小区内的指定位置。但是垃圾运出去还需要额外花钱，如果买房的时候交过垃圾清运费就可以不用管，如果没交那么就自己找人拖走或者交代物业运走，一般多的话会有个小几百。

✨ 注意冰箱位置，如果是零嵌要提前选好冰箱来做，不然的话一般装修公司预留的深度会很小(柜子的深度60)，很难选冰箱。

水电

✨ 如果想要只能家具，千万记得开关盒中留零线！但是留了零线接线方式和传统的双控、三控是不一样的，所以做之前要做好规划。

✨ 热水器如果想要使用零冷水功能，千万记得要留回水管!虽然后期可以加装U型阀，但是效果肯定没加回水管的好。

✨ 冰箱单独走线!

✨ 如果门口需要加摄像头，记得预留一根线到门外，可以和弱电箱的一路。

✨ 记得在窗户旁边加插座，方便后期加智能窗帘，可以不用不能没有。

✨ 卫生间可以加电热毛巾架、智能马桶的电位。

✨ 浴室柜后记得留电位，可以后面用智能镜柜。

✨ 厨房开关插座买带开关的，省的一直插拔。

✨ 水一般走天，电走地，不要开横槽，管道从地面走，反正后面地面会封起来。

✨ 保证每个房间都有网线能到，根据自己要做有线mesh还是ap面板来选择，推荐有线mesh。可以通三根网线从弱电箱到电视下方，两根有线mesh用，一根iptv。

✨ 如果洗衣机在阳台，千万要留地漏，装修公司一般都不在那边留地漏怕反水，可以买个止逆的地漏，万一阳台水管真出问题，可能把整个地板泡掉得不偿失。

✨ 如果装中央空调，一般是不包中央空调的电源线的，要额外花钱！

木工

✨ 木工现在活很少一般就是掉个顶，做窗帘盒、幕布盒之类的。

✨ 如果是木工打的柜子就需要这个阶段来做，因为我是全屋定制这个不是很清楚。

瓦工

✨ 瓦工要看师傅的人品的！有的师傅手艺差人品差，贴的砖一揭就掉下来。

✨ 铺装前要先让瓷砖供货商给出铺装方案，建议通铺。我家是厨房客厅通铺，卧室书房是地板。

✨ 验收的时候要检验每一块墙砖的空鼓情况，不管师傅手艺多好肯定还是有这种情况存在，边缘的可以注浆。

✨ 建议不要做壁龛没啥用。如果做了壁龛内部要留坡度方便水出来。

✨ 卫生间要做48小时防水实验，48小时后要去楼下邻居家看看有没有漏水的情况。

油漆

✨ 墙固要留到现在才刷，有些装修公司会做面子工程一开始就做，但是时间太久到油漆阶段上面全是灰。

其他补充

✅ 加了不少商品在购物车发现还是京东5月31号预售的优惠力度最大，大件家电有个定金一般都能抵500左右。
✅ 智能家居一般就是绿米的zigbee和小米的蓝牙mesh或者wifi协议。根据自身情况选择，最好的肯定是智能开关+智能灯，但是太贵了。可以选择凌动开关+智能灯。凌动开关其实就是价格弹簧回弹保持通电需要在米家里面打开智能灯的凌动功能才能用。

spring boot解密数据体

2023-05-12T02:02:00.000Z

有这样一个需求，拿到一份其他园区的五位一体数据对接文档，要求根据文档实现类似的服务端提供企业传输数据‘

实现方式（下文采用的是HttpMessageConverter的方式，还有其他方式暂不列举）

消息转换器

package com.lyc.wwyt.config.convert;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lyc.wwyt.exception.DecryptException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.util.StreamUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Collections;
import java.util.List;
import java.util.Map;

public class DecryptingHttpMessageConverter extends MappingJackson2HttpMessageConverter {
    private static final String KEY = "xxxxxxxxxxxxxxxxx";
    private static final String INITIALIZATION_VECTOR = "xxxxxxxxxxxxxxxxx";

    private final ObjectMapper objectMapper;

    public DecryptingHttpMessageConverter(ObjectMapper objectMapper) {
        super(objectMapper);
        this.objectMapper = objectMapper;
        setSupportedMediaTypes(Collections.singletonList(MediaType.APPLICATION_JSON));
    }

    @Override
    public boolean canRead(Class clazz, MediaType mediaType) {
        return true;
    }

    @Override
    public Object read(Type type, Class clazz, HttpInputMessage inputMessage) throws IOException {
        JavaType javaType = this.getJavaType(type, clazz);
        String body = StreamUtils.copyToString(inputMessage.getBody(), StandardCharsets.UTF_8);
        Map map = objectMapper.readValue(body, new TypeReference>() {
        });
        String encryptedDatas = (String) map.get("datas");
        String decryptedDatas = decrypt(encryptedDatas);
        String decryptedBody;
        if (List.class.isAssignableFrom(javaType.getRawClass())) {
            List> decryptedList = objectMapper.readValue(decryptedDatas, new TypeReference>>() {
            });
            decryptedBody = objectMapper.writeValueAsString(decryptedList);
        } else {
            Map decryptedMap = objectMapper.readValue(decryptedDatas, new TypeReference>() {
            });
            map.putAll(decryptedMap);
            map.remove("datas");
            decryptedBody = objectMapper.writeValueAsString(map);
        }

        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decryptedBody.getBytes());
        HttpHeaders headers = inputMessage.getHeaders();
        return this.objectMapper.readValue(byteArrayInputStream, javaType);
    }

    private String decrypt(String encrypted) {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            SecretKeySpec key = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
            IvParameterSpec iv = new IvParameterSpec(INITIALIZATION_VECTOR.getBytes(StandardCharsets.UTF_8));
            cipher.init(Cipher.DECRYPT_MODE, key, iv);
            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(encrypted));
            return new String(decrypted, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new DecryptException();
        }
    }
}

将其添加到消息转换器中

package com.lyc.wwyt.config.convert;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;
import java.util.List;

/**
 * 类 WebMvcConfig
 *
 * @author ChenQi
 * @date 2023/5/11
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Resource
    private ObjectMapper objectMapper;

    @Override
    public void extendMessageConverters(List> converters) {
        converters.add(0, new DecryptingHttpMessageConverter(objectMapper));
    }
}

实现效果

代码地址

源码

在CenterOS搭建ELK日志监控分析平台

2023-04-20T02:00:00.000Z

准备环境

确保你的 CentOS 系统已经更新到最新版本，并安装了必要的依赖。如果es版本选择8.0以上则jdk至少17以上

1 2	sudo yum update -y sudo yum install -y wget curl vim

Elasticsearch

安装 Elasticsearch

首先，你需要导入 Elasticsearch 的 GPG key，然后添加其仓库

1	sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

创建一个新的 Elasticsearch YUM repository 文件

1	sudo vim /etc/yum.repos.d/elasticsearch.repo

将以下内容添加到文件中：

[elasticsearch-8.x]
name=Elasticsearch repository for 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

现在，你可以安装 Elasticsearch 了

1	sudo yum install -y elasticsearch

优化 Elasticsearch 内存占用

编辑 Elasticsearch 的配置文件，限制内存占用

1	sudo vim /etc/elasticsearch/jvm.options

找到以下两行，将堆内存限制在较低的范围内，例如

1 2	-Xms1024m -Xmx1024m

安装并配置分词插件

在这个例子中，我们以中文分词插件 IK 分词器为例

1	sudo /usr/share/elasticsearch/bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v8.7.0/elasticsearch-analysis-ik-8.7.0.zip

移动es到指定目录

mv /usr/share/elasticsearch/ /home
cd /home/elasticsearch/
mkdir data
mkdir logs
mv /var/lib/elasticsearch/* /home/elasticsearch/data

生成证书

1 2	./bin/elasticsearch-certutil ca ./bin/elasticsearch-certutil cert --ca elastic-stack-ca.p12

修改配置文件

1	vim /etc/elasticsearch/elasticsearch.yml

修改内容如下

path.data: /home/elasticsearch/data
path.logs: /home/elasticsearch/logs
node.max_local_storage_nodes: 2
node.name: node-1
network.host: 0.0.0.0
cluster.initial_master_nodes: ["node-1"]
# 开启安全认证
xpack.security.enabled: true
# 开启ssl
xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
# 生成ca证书
xpack.security.transport.ssl.keystore.path: /home/elasticsearch/elastic-certificates.p12
xpack.security.transport.ssl.truststore.path: /home/elasticsearch/elastic-certificates.p12

创建对应的用户以启动ES

groupadd es 
# -g 指定组 -p 密码
useradd es -g es -p password 
# -R 处理指定目录以及其子目录下的所有文件
chown es:es -R es安装目录 
chown es:es -R /var/log
chown es:es -R /tmp

切换刚创建的用户并启动 Elasticsearch

1 2	su es ./bin/elasticsearch -d

配置密码(多个)

1	./bin/elasticsearch-setup-passwords interactive

Kibana

安装Kibana

1	sudo yum install kibana

移动目录

cd /home
mkdir kibana
mv /usr/share/kibana/* /home/kibana/
cd /kibana
mkdir config
mv /etc/kibana/* /home/kibana/config/

修改配置文件

1	vim /etc/kibana/kibana.yml

增加以下内容

# 服务端口
server.port: 5601
# 服务器ip  本机
server.host: "0.0.0.0"
# Elasticsearch 服务地址
elasticsearch.hosts: ["http://localhost:9200"]
# 设置语言为中文
i18n.locale: "zh-CN"
#设置访问用户
elasticsearch.username: "kibana"
#设置访问密码
elasticsearch.password: "上面es中kibana设置的密码"
xpack.encryptedSavedObjects.encryptionKey: "your_encryption_key"

修改以下内容

1	pid.file: /home/kibana/kibana.pid

指定用户授权

1	chown es:es -R /home/kibana/

启动并启用Kibana服务

nohup ./bin/kibana &

# 查看进程对应的pid
netstat -nlp | grep 5601

Logstash

安装Logstash

1	sudo yum install logstash

移动目录

cd /home
mkdir logstash
mv /usr/share/logstash/* /home/logstash/
mv /etc/logstash/* /home/logstash/

配置Logstash

1 2	cd /home/logstash/config vim config/logstash-es.conf

一个简单的Logstash配置示例

# 收集指定文件的日志
input {
  file {
    path => "/path/to/your/logfile.log"
    start_position => "beginning"
    sincedb_path => "/dev/null"
  }
}
# 指定目录下所有日志文件
input {
  file {
    path => "/path/to/your/log-directory/*.log"
    start_position => "beginning"
    sincedb_path => "/path/to/sincedb/file"
  }
}
# 使用api收集
input {
  tcp {
    port => 9601
    codec => json_lines
  }
}

filter {
  # Add your filters here
}

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "logstash-%{+YYYY.MM.dd}"
    user => "your_username"
    password => "your_password"
  }
}

start_position 参数表示 Logstash 应从文件的哪个位置开始读取，beginning 表示从文件开头开始。sincedb_path 参数可以指定一个文件路径来记录已经处理过的文件位置。您可以选择一个目录以存储这些 sincedb 文件，以便在 Logstash 重新启动时，它可以记住上次处理到的文件位置。设置为 /dev/null 以确保每次启动 Logstash 时都从头开始读取。

安装插件

vim Gemfile

将其中source "https://rubygems.org"修改为
source "https://gems.ruby-china.com"

./bin/logstash-plugin install logstash-codec-json_lines

找不到源改为本地安装

插件库

# 修改Gemfile
gem "logstash-codec-json_lines", :path => "./logstash-codec-json_lines"

# 执行安装
./bin/logstash-plugin install --no-verify

指定用户授权

1	chown es:es -R /home/logstash/

启动Logstash服务

1	nohup ./bin/logstash -f ./config/logstash-es.conf &

配置防火墙

如果CentOS系统启用了防火墙，需要打开Elasticsearch和Kibana使用的端口并且在云主机上安全组中相应配置这两个端口

sudo firewall-cmd --add-port=9200/tcp --permanent
sudo firewall-cmd --add-port=5601/tcp --permanent
sudo firewall-cmd --add-port=9601/tcp --permanent
sudo firewall-cmd --reload

在java中使用

添加依赖

<dependency>
    <groupId>net.logstash.logbackgroupId>
    <artifactId>logstash-logback-encoderartifactId>
    <version>7.3version>
dependency>

修改logback-spring.xml

"1.0" encoding="UTF-8"?>
configuration>
<configuration>
    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        
        <destination>部署ip:9601destination>
        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder" />
    appender>

    
    <include resource="org/springframework/boot/logging/logback/base.xml"/>

    <root level="INFO">
        
        <appender-ref ref="LOGSTASH" />
    root>

configuration>

同时从api和本地收集日志，并且指定到不同的索引中

input {
  tcp {
    port => 9601
    codec => json_lines
type => "java_api"
  }
}
input {
  file {
    path => "需要收集日日志的目录/*"
    start_position => "beginning"
    sincedb_path => "/dev/null"
type => "java_local"
  }
}
output {
  if [type] == "java_api" {
    elasticsearch {
hosts => ["localhost:9200"]
index => "java_api-%{+YYYY.MM.dd}"
user => "elastic"
password => "你的密码"
  }
  }
  if [type] == "java_local" {
    elasticsearch {
hosts => ["localhost:9200"]
index => "java_local-%{+YYYY.MM.dd}"
user => "elastic"
password => "你的密码"
  }
  }
  stdout {
  codec => rubydebug
  }
}

集成skywalking

下载

https://www.apache.org/dyn/closer.cgi/skywalking/9.4.0/apache-skywalking-apm-9.4.0-src.tgz

解压并移动到指定目录

tar -zxvf apache-skywalking-apm-9.4.0-src.tgz

# 移动文件
mv /home/skywalking/apache-skywalking-apm-9.4.0/* /home/skywalking/

配置 SkyWalking

编辑 SkyWalking 的配置文件 /home/skywalking/oap-server/server-starter/src/main/resources/application.yml，根据实际情况修改 storage 配置。例如，如果你打算使用 Elasticsearch 作为存储后端，你需要修改以下内容：

storage:
  selector: ${SW_STORAGE:elasticsearch}
  elasticsearch:
    nameSpace: ${SW_NAMESPACE:""}
    clusterNodes: ${SW_STORAGE_ES_CLUSTER_NODES:}
    user: ${SW_ES_USER:""}
    password: ${SW_ES_PASSWORD:""}

编译

# 在解压目录下而不是bin目录下,确保环境中java版本>=11,maven版本>=3.6
cd /home/skywalking
mvn wrapper:wrapper
./mvnw clean package -Dmaven.test.skip

启动 SkyWalking

1 2	cd /home/skywalking/dist-material/bin/ ./startup.sh

判断是否启动成功

打开目录/home/skywalking/dist-material/logs查看日志即可

windows中开机自启动

2023-04-17T08:36:00.000Z

exe程序，比如nginx.exe

写一个bat，内容为

@echo off
SET NGINX_HOME=nginx.exe所在的目录
cd %NGINX_HOME%
start nginx.exe

然后讲该bat放入目录C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp此目录可以通过在搜索中直接键入shell:startup运行

使用该方法可以不用下载并配置指定的服务工具，避免有的windows中权限不够无法安装.netframwork3.5无法使用注册服务。

重新开机后可以看到该程序已启动

其他服务比如java服务

不注册系统服务

启动jar的bat

1
2
3

@echo off
cd /d "jar包所在目录"
start javaw -jar "jar包名称.jar"

考虑到jar服务要依赖与一些服务，比如必须等redis启动后再启动

@echo off
SET REDIS_HOME=redis所在的目录
cd %REDIS_HOME%
echo Waiting for Redis to start...

:redis
ping 127.0.0.1 -n 2 > nul
redis-cli ping > nul || goto redis

echo Redis has started, starting your jar...
cd /d "jar包所在目录"
start javaw -jar "jar包名称.jar"

上述情况直接将该bat放置在C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp中即可实现开机自启，此目录可以通过在搜索中直接键入shell:startup运行

注册到系统服务(此方法同样适用于exe文件)

下载Windows Service Wrapper 工具
点此下载

jar-service.xml

<service>
  <id>runJarid>
  <name>runJar Servicename>
  <description>需要自启动服务的描述description>
  <logpath>日志保存路径logpath>
  <log mode="roll-by-size">
    <sizeThreshold>10240sizeThreshold>
    <keepFiles>8keepFiles>
  log>
  <executable>启动jar的batexecutable>
service>

run.bat

1	java -jar jar包名称.jar

装载服务

# 安装服务 
jar-service.exe install
# 卸载服务 
jar-service.exe uninstall

自带注册服务的exe如redis

一般来说安装时就会自动注册相关的服务

如果没有注册就自行注册

1	redis-server.exe --service-install redis.windows.conf

ssl证书自动续期

2023-04-11T09:45:00.000Z

安装acme.sh

curl https://get.acme.sh | sh
# 国内
curl https://gitee.com/neilpang/acme.sh | sh
source ~/.bashrc

# 开启自动升级
acme.sh  --upgrade  --auto-upgrade

升级CA

1	yum update ca-certificates

将acme切换到Let’s Encrypt的CA

1	acme.sh --set-default-ca --server letsencrypt

签发证书

因为我的nginx 443反代到一个网站，80端口是空闲的，所以我下面使用的是acme.sh伪装自己为一个webserver的方式，其他方式

防火墙放开80端口

安装socat

1	yum install socat

签发证书

1	acme.sh --issue -d 需要签发的域名 --standalone

安装证书到指定目录,并执行新域名后需要重启的应用,如xray,nginx。acme.sh将记住操作并

~/.acme.sh/acme.sh --install-cert -d 需要签发的域名 \
--key-file       /usr/local/nginx/ssl/需要签发的域名.key  \
--fullchain-file /usr/local/nginx/ssl/需要签发的域名.key.pem \
--reloadcmd     "service nginx force-reload"

(一个小提醒, 这里用的是 service nginx force-reload, 不是 service nginx reload, 据测试, reload 并不会重新加载证书, 所以用的 force-reload)

Nginx 的配置 ssl_certificate 使用 /etc/nginx/ssl/fullchain.cer ，而非 /etc/nginx/ssl/.cer ，否则 SSL Labs 的测试会报 Chain issues Incomplete 错误。

--install-cert命令可以携带很多参数, 来指定目标文件. 并且可以指定 reloadcmd, 当证书更新以后, reloadcmd会被自动调用,让服务器生效。

查看定时任务确保会自动执行

1	crontab -l

查看已安装的证书信息

1	acme.sh --info -d 需要签发的域名

spring boot+mybatis plus进行sql拦截实现权限过滤，使用mybatis plus的DataPermissionHandler

2023-03-29T03:33:00.000Z

📃 关联文档

📄 前置文档

自定义一个AllbsDataPermissionHandler，使用mybatis plus自带的是可以的，主要考虑到后面还有其他自定义效果，所以单独写了一个

import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.schema.Table;

/**
 * 接口 AllbsDataPermissionHandler
 *
 * @author ChenQi
 * @date 2023/3/28
 */
public interface AllbsDataPermissionHandler {

    /**
     * 获取数据权限 SQL 片段
     *
     * @param table             表相关信息
     * @param where             待执行 SQL Where 条件表达式
     * @param mappedStatementId Mybatis MappedStatement Id 根据该参数可以判断具体执行方法
     * @return JSqlParser 条件表达式，返回的条件表达式会覆盖原有的条件表达式
     */
    Expression getSqlSegment(final Table table, Expression where, String mappedStatementId);
}

将mybatis plus中的`PluginUtils`工具类抽出使用，主要是为了解决其中方法jdk17不兼容的问题

当然以下代码还没改，后续更改了之后文档再更新

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.apache.ibatis.session.Configuration;

import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * 说明: 从mybatis plus中抽出来主要是为了解决jdk17不兼容 realTarget 方法的问题、减少cpu占用
 */
public abstract class PluginUtils {
    public static final String DELEGATE_BOUNDSQL_SQL = "delegate.boundSql.sql";

    /**
     * 获得真正的处理对象,可能多层代理.
     */
    @SuppressWarnings("unchecked")
    public static  T realTarget(Object target) {
        if (Proxy.isProxyClass(target.getClass())) {
            MetaObject metaObject = SystemMetaObject.forObject(target);
            return realTarget(metaObject.getValue("h.target"));
        }
        return (T) target;
    }

    /**
     * 给 BoundSql 设置 additionalParameters
     *
     * @param boundSql             BoundSql
     * @param additionalParameters additionalParameters
     */
    public static void setAdditionalParameter(BoundSql boundSql, Map additionalParameters) {
        additionalParameters.forEach(boundSql::setAdditionalParameter);
    }

    public static PluginUtils.MPBoundSql mpBoundSql(BoundSql boundSql) {
        return new PluginUtils.MPBoundSql(boundSql);
    }

    public static PluginUtils.MPStatementHandler mpStatementHandler(StatementHandler statementHandler) {
        statementHandler = realTarget(statementHandler);
        MetaObject object = SystemMetaObject.forObject(statementHandler);
        return new PluginUtils.MPStatementHandler(SystemMetaObject.forObject(object.getValue("delegate")));
    }

    /**
     * {@link org.apache.ibatis.executor.statement.BaseStatementHandler}
     */
    public static class MPStatementHandler {
        private final MetaObject statementHandler;

        MPStatementHandler(MetaObject statementHandler) {
            this.statementHandler = statementHandler;
        }

        public ParameterHandler parameterHandler() {
            return get("parameterHandler");
        }

        public MappedStatement mappedStatement() {
            return get("mappedStatement");
        }

        public Executor executor() {
            return get("executor");
        }

        public PluginUtils.MPBoundSql mPBoundSql() {
            return new PluginUtils.MPBoundSql(boundSql());
        }

        public BoundSql boundSql() {
            return get("boundSql");
        }

        public Configuration configuration() {
            return get("configuration");
        }

        @SuppressWarnings("unchecked")
        private  T get(String property) {
            return (T) statementHandler.getValue(property);
        }
    }

    /**
     * {@link BoundSql}
     */
    public static class MPBoundSql {
        private final MetaObject boundSql;
        private final BoundSql delegate;

        MPBoundSql(BoundSql boundSql) {
            this.delegate = boundSql;
            this.boundSql = SystemMetaObject.forObject(boundSql);
        }

        public String sql() {
            return delegate.getSql();
        }

        public void sql(String sql) {
            boundSql.setValue("sql", sql);
        }

        public List parameterMappings() {
            List parameterMappings = delegate.getParameterMappings();
            return new ArrayList<>(parameterMappings);
        }

        public void parameterMappings(List parameterMappings) {
            boundSql.setValue("parameterMappings", Collections.unmodifiableList(parameterMappings));
        }

        public Object parameterObject() {
            return get("parameterObject");
        }

        public Map additionalParameters() {
            return get("additionalParameters");
        }

        @SuppressWarnings("unchecked")
        private  T get(String property) {
            return (T) boundSql.getValue(property);
        }
    }
}

自定义一个注解，用于标注实体类中的需要过滤的字段

目前只取获取到的第一个字段，你要是标多个我也没办法

import java.lang.annotation.*;

/**
 * 注解 ScopeField
 *
 * @author ChenQi
 * @date 2023/3/28
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.ANNOTATION_TYPE})
public @interface ScopeField {

    /**
     * 字段名（该值可无）
     */
    String value() default "";
}

数据权限处理器

用于传递重新拼sql时所需的一些参数，新增的情况暂时还未处理，后续继续更新

import com.baomidou.mybatisplus.core.plugins.InterceptorIgnoreHelper;
import com.baomidou.mybatisplus.extension.parser.JsqlParserSupport;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import lombok.*;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SelectBody;
import net.sf.jsqlparser.statement.select.SetOperationList;
import net.sf.jsqlparser.statement.update.Update;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;

import java.sql.Connection;
import java.util.List;

/**
 * 数据权限处理器
 * 类 DataPermissionInterceptor
 *
 * @author ChenQi
 * @date 2023/3/28
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@SuppressWarnings({"rawtypes"})
public class DataPermissionInterceptor extends JsqlParserSupport implements InnerInterceptor {
    private AllbsDataPermissionHandler dataPermissionHandler;

    @Override
    public void beforePrepare(StatementHandler sh, Connection connection, Integer transactionTimeout) {
        PluginUtils.MPStatementHandler mpSh = PluginUtils.mpStatementHandler(sh);
        MappedStatement ms = mpSh.mappedStatement();
        SqlCommandType sct = ms.getSqlCommandType();
        if (sct == SqlCommandType.UPDATE || sct == SqlCommandType.DELETE || sct == SqlCommandType.SELECT) {
            if (InterceptorIgnoreHelper.willIgnoreDataPermission(ms.getId())) {
                return;
            }
            PluginUtils.MPBoundSql mpBs = mpSh.mPBoundSql();
            mpBs.sql(parserMulti(mpBs.sql(), ms.getId()));
        }
    }

    /**
     * 查询
     */
    @Override
    protected void processSelect(Select select, int index, String sql, Object obj) {
        SelectBody selectBody = select.getSelectBody();
        if (selectBody instanceof PlainSelect) {
            this.setWhere((PlainSelect) selectBody, (String) obj);
        } else if (selectBody instanceof SetOperationList) {
            SetOperationList setOperationList = (SetOperationList) selectBody;
            List selectBodyList = setOperationList.getSelects();
            selectBodyList.forEach(s -> this.setWhere((PlainSelect) s, (String) obj));
        }
    }

    /**
     * 新增
     */
    @Override
    protected void processInsert(Insert insert, int index, String sql, Object obj) {
        throw new UnsupportedOperationException();
    }

    /**
     * 删除
     */
    @Override
    protected void processDelete(Delete delete, int index, String sql, Object obj) {
        final Expression sqlSegment = getUpdateOrDeleteExpression(delete.getTable(), delete.getWhere(), (String) obj);
        if (null != sqlSegment) {
            delete.setWhere(sqlSegment);
        }
    }

    /**
     * 更新
     */
    @Override
    protected void processUpdate(Update update, int index, String sql, Object obj) {
        final Expression sqlSegment = getUpdateOrDeleteExpression(update.getTable(), update.getWhere(), (String) obj);
        if (null != sqlSegment) {
            update.setWhere(sqlSegment);
        }
    }

    /**
     * 设置 where 条件
     *
     * @param plainSelect  查询对象
     * @param whereSegment 查询条件片段
     */
    protected void setWhere(PlainSelect plainSelect, String whereSegment) {
        Table table = (Table) plainSelect.getFromItem();
        Expression sqlSegment = dataPermissionHandler.getSqlSegment(table, plainSelect.getWhere(), whereSegment);
        if (null != sqlSegment) {
            plainSelect.setWhere(sqlSegment);
        }
    }

    protected Expression getUpdateOrDeleteExpression(final Table table, final Expression where, final String whereSegment) {
        return dataPermissionHandler.getSqlSegment(table, where, whereSegment);
    }
}

核心，进行sql重新封装的处理

import cn.allbs.allbsjwt.config.utils.SecurityUtils;
import cn.allbs.allbsjwt.config.vo.SysUser;
import cn.allbs.common.constant.StringPool;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Alias;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.InExpression;
import net.sf.jsqlparser.expression.operators.relational.ItemsList;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;

import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.Set;

/**
 * 类 CustomPermissionHandler
 *
 * @author ChenQi
 * @date 2023/3/28
 */
@Slf4j
public class CustomPermissionHandler implements AllbsDataPermissionHandler {

    private final static String DEFAULT_FILTER_FIELD = "ent_id";

    /**
     * 获取数据权限 SQL 片段
     *
     * @param where             待执行 SQL Where 条件表达式
     * @param mappedStatementId Mybatis MappedStatement Id 根据该参数可以判断具体执行方法
     * @return JSqlParser 条件表达式
     */
    @Override
    public Expression getSqlSegment(final Table table, Expression where, String mappedStatementId) {

        // 在有权限的情况下查询用户所关联的企业列表
        SysUser sysUser = SecurityUtils.getUser();
        // 如果非权限用户则不往下执行，执行原sql
        if (sysUser == null) {
            return where;
        }
        Set permissionEntList = sysUser.getEntIdList();
//        if (permissionEntList.size() == 0) {
//            return where;
//        }
        TableInfo tableInfo = TableInfoHelper.getTableInfo(table.getName());
        String fieldName = tableInfo.getFieldList().stream()
                .filter(a -> a.getField().getAnnotation(ScopeField.class) != null)
                .map(a -> a.getField().getAnnotation(ScopeField.class).value())
                .findFirst()
                .orElse(DEFAULT_FILTER_FIELD);
        Alias fromItemAlias = table.getAlias();
        String finalFieldName = Optional.ofNullable(fromItemAlias).map(a -> a.getName() + StringPool.DOT + fieldName).orElse(fieldName);

        if (permissionEntList.size() > 1) {
            // 把集合转变为 JSQLParser需要的元素列表
            InExpression inExpression = new InExpression(new Column(finalFieldName), getItemList(permissionEntList));

            // 组装sql
            return where == null ? inExpression : new AndExpression(where, inExpression);
        }
        // 设置where
        EqualsTo equalsTo = new EqualsTo();
        equalsTo.setLeftExpression(new Column(finalFieldName));
        equalsTo.setRightExpression(new LongValue(permissionEntList.stream().findFirst().orElse(0L)));
        return where == null ? equalsTo : new AndExpression(where, equalsTo);
    }

    private ItemsList getItemList(Set permissionEntList) {
        List list = new LinkedList<>();
        for (Long aLong : permissionEntList) {
            try {
                Expression expression = CCJSqlParserUtil.parseCondExpression(StrUtil.join(",", aLong));
                list.add(expression);
            } catch (JSQLParserException e) {
                log.error("筛选数据转换为表达式失败!" + e.getLocalizedMessage());
            }
        }
        return new ExpressionList(list);
    }
}

最后将改插件注册进mybatis plus即可

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 类 MybatisPlusCustomConfig
 *
 * @author ChenQi
 * @date 2023/3/28
 */
@Configuration
public class MybatisPlusCustomConfig {

    @Bean
    public MybatisPlusInterceptor customMybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 数据权限
        DataPermissionInterceptor dataPermissionInterceptor = new DataPermissionInterceptor(new CustomPermissionHandler());
        interceptor.addInnerInterceptor(dataPermissionInterceptor);
        return interceptor;
    }
}

说明

所有sql将默认拦截并自动拼接筛选条件
如果想要对部分sql不进行筛选，则在dao层的类名上添加注解@InterceptorIgnore或者dao层的某个方法上添加注解@InterceptorIgnore
如果想要使用mybatis plus自带的sdk并使其中某些方法不进行数据筛选，则重新写一个接口集成BaseMapper,单独对其中的某个方法添加注解。

import com.baomidou.mybatisplus.annotation.InterceptorIgnore;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Component;

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

/**
 * 类 DataScopeMapper
 *
 * @author ChenQi
 * @date 2023/3/28
 */
@Mapper
@Component
public interface DataScopeMapper extends BaseMapper {

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    @Override
    @InterceptorIgnore
    T selectById(Serializable id);

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Override
    List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Override
    extends IPage> P selectPage(P page, @Param(
        Constants.WRAPPER) Wrapper queryWrapper);
}

可以进行功能反转，比如目前是全部sql拦截，添加注解不拦截。可以修改beforePrepare使其默认全部不拦截，添加了该注解的方法拦截sql并重新组装。
如果不想违反mybatis plus注解本意，可以重新自定义一个注解来达成上述效果，本文不做展示，参考上一篇即可实现。

添加新增、更新、批量新增、批量更新的数据过滤

使用

AllbsDataPermissionHandler添加两个方法用于处理新增和更新。具体实现效果看

/**
     * 新增数据时 判断是否存在越权行为，如果存在这种行为则进行拦截并重组sql
     *
     * @param insertStmt Insert
     * @param boundSql   BoundSql
     */
void insertParameter(Insert insertStmt, BoundSql boundSql);

    /**
     * 更新数据时 判断是否存在越权行为，如果存在这种行为则进行拦截并重组sql
     *
     * @param updateStmt      Update
     * @param mappedStatement MappedStatement
     * @param boundSql        BoundSql
     */
void updateParameter(Update updateStmt, MappedStatement mappedStatement, BoundSql boundSql);

CustomPermissionHandler的实现

package cn.allbs.allbsjwt.config.datascope.mapper;

import cn.allbs.allbsjwt.config.utils.SecurityUtils;
import cn.allbs.allbsjwt.config.vo.SysUser;
import cn.allbs.common.constant.StringPool;
import cn.allbs.mybatis.datascope.DataPmsHandler;
import cn.allbs.mybatis.datascope.ScopeField;
import cn.allbs.mybatis.execption.UserOverreachException;
import cn.allbs.mybatis.utils.PluginUtils;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.expression.Alias;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.InExpression;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.update.Update;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Optional;
import java.util.Set;

/**
 * 类 CustomPermissionHandler
 *
 * @author ChenQi
 * @date 2023/3/28
 */
@Slf4j
@Component
public class CustomPermissionHandler implements DataPmsHandler {

    private final static String DEFAULT_FILTER_FIELD = "ent_id";

    /**
     * 获取数据权限 SQL 片段
     *
     * @param where             待执行 SQL Where 条件表达式
     * @param mappedStatementId Mybatis MappedStatement Id 根据该参数可以判断具体执行方法
     * @return JSqlParser 条件表达式
     */
    @Override
    public Expression getSqlSegment(final Table table, Expression where, String mappedStatementId) {

        // 在有权限的情况下查询用户所关联的企业列表
        SysUser sysUser = SecurityUtils.getUser();
        // 如果非权限用户则不往下执行，执行原sql
        if (sysUser == null) {
            return where;
        }
        Set permissionEntList = sysUser.getEntIdList();
//        if (permissionEntList.size() == 0) {
//            return where;
//        }
        TableInfo tableInfo = TableInfoHelper.getTableInfo(table.getName());
        String fieldName = tableInfo.getFieldList().stream()
                .filter(a -> a.getField().getAnnotation(ScopeField.class) != null)
                .map(a -> a.getField().getAnnotation(ScopeField.class).value())
                .findFirst()
                .orElse(DEFAULT_FILTER_FIELD);
        Alias fromItemAlias = table.getAlias();
        String finalFieldName = Optional.ofNullable(fromItemAlias).map(a -> a.getName() + StringPool.DOT + fieldName).orElse(fieldName);

        if (permissionEntList.size() > 1) {
            // 把集合转变为 JSQLParser需要的元素列表
            InExpression inExpression = new InExpression(new Column(finalFieldName), PluginUtils.getItemList(permissionEntList));

            // 组装sql
            return where == null ? inExpression : new AndExpression(where, inExpression);
        }
        // 设置where
        EqualsTo equalsTo = new EqualsTo();
        equalsTo.setLeftExpression(new Column(finalFieldName));
        equalsTo.setRightExpression(new LongValue(permissionEntList.stream().findFirst().orElse(0L)));
        return where == null ? equalsTo : new AndExpression(where, equalsTo);
    }

    @Override
    public void updateParameter(Update updateStmt, MappedStatement mappedStatement, BoundSql boundSql) {
        TableInfo tableInfo = TableInfoHelper.getTableInfo(updateStmt.getTable().getName());
        parameterHandler(tableInfo.getFieldList(), boundSql);
    }

    @Override
    public void insertParameter(Insert insertStmt, BoundSql boundSql) {
        TableInfo tableInfo = TableInfoHelper.getTableInfo(insertStmt.getTable().getName());
        parameterHandler(tableInfo.getFieldList(), boundSql);
    }

    private void parameterHandler(List fieldList, BoundSql boundSql) {
        // 过滤数据
        SysUser sysUser = SecurityUtils.getUser();
        // 如果当前用户是超级管理员，不处理
        if (sysUser.getId() == 1L) {
            return;
        }
        // 获取当前用户所具备的ent_id
        Set permissionEntList = sysUser.getEntIdList();

        // 获取当前表中需要权限过滤的字段名称
        String fieldName = fieldList.stream()
                .filter(a -> a.getField().getAnnotation(ScopeField.class) != null)
                .map(a -> a.getField().getAnnotation(ScopeField.class).value())
                .findFirst()
                .orElse(DEFAULT_FILTER_FIELD);

        MetaObject metaObject = SystemMetaObject.forObject(boundSql.getParameterObject());

        for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
            String propertyName = parameterMapping.getProperty();
            if (propertyName.startsWith("ew.paramNameValuePairs")) {
                continue;
            }
            String[] arr = propertyName.split("\\.");
            String propertyNameTrim = arr[arr.length - 1].replace("_", "").toUpperCase();
            if (fieldName.replaceAll("[._\\-$]", "").toUpperCase().equals(propertyNameTrim)) {
                if (!Optional.ofNullable(metaObject.getValue(propertyName)).isPresent()) {
                    return;
                }
                long currentEntId = Long.parseLong(metaObject.getValue(propertyName).toString());
                // 判断是否在权限范围内
                if (permissionEntList.contains(currentEntId)) {
                    metaObject.setValue(propertyName, currentEntId);
                } else {
                    // 可以直接抛出异常 or 使用当前用户的ent_id 替换插入值 or 直接忽略当前插入sql但不抛出异常
                    throw new UserOverreachException();
                }
            }

        }
    }
}

关联查询

更新

删除

代码地址

引用站外地址

权限过滤使用demo

github

上文代码在目录cn.allbs.allbsjwt.config.datascope下，可以查看git提交记录，后面使用封装好的allbs-mybatis包就被我删了。

引用站外地址

权限过滤封装源码

github

自定义格式化mybatis、mybatis plus中打印的sql

2023-03-27T03:02:00.000Z

前提条件

连接池使用的是阿里的druid，其他连接池后续有空再考虑

继承`FilterEventAdapter`并重写`statement_close`和`resultSet_next`

statement_close 用于格式化`delete`,`insert`(没有主键id返回),`update`

`resultSet_next` 用户格式化`select`,`insert`（有主键id返回）

代码

package cn.allbs.mybatis.filter;

import cn.allbs.common.constant.DateConstant;
import cn.allbs.mybatis.properties.MybatisProperties;
import cn.allbs.mybatis.utils.TableConsoleUtil;
import com.alibaba.druid.DbType;
import com.alibaba.druid.filter.FilterChain;
import com.alibaba.druid.filter.FilterEventAdapter;
import com.alibaba.druid.proxy.jdbc.JdbcParameter;
import com.alibaba.druid.proxy.jdbc.ResultSetProxy;
import com.alibaba.druid.proxy.jdbc.StatementProxy;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.util.StringUtils;
import lombok.extern.slf4j.Slf4j;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Types;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.util.*;

/**
 * 类 DruidSqlLogFilter
 * 
 *
 * @author ChenQi
 * @since 2023/3/23 9:55
 */
@Slf4j
public class DruidSqlLogFilter extends FilterEventAdapter {

    private static final SQLUtils.FormatOption FORMAT_OPTION = new SQLUtils.FormatOption(false, false);

    private final MybatisProperties mybatisProperties;

    private boolean first = true;

    private static final Set BLOB_TYPES = new HashSet<>();

    private ResultSet rs;
    private final Set blobColumns = new HashSet<>();

    private int rows;

    private List rowList = new LinkedList<>();

    private boolean STATEMENT_CLOSE_RUN = true;

    static {
        BLOB_TYPES.add(Types.BINARY);
        BLOB_TYPES.add(Types.BLOB);
        BLOB_TYPES.add(Types.CLOB);
        BLOB_TYPES.add(Types.LONGNVARCHAR);
        BLOB_TYPES.add(Types.LONGVARBINARY);
        BLOB_TYPES.add(Types.LONGVARCHAR);
        BLOB_TYPES.add(Types.NCLOB);
        BLOB_TYPES.add(Types.VARBINARY);
    }

    public DruidSqlLogFilter(MybatisProperties mybatisProperties) {
        this.mybatisProperties = mybatisProperties;
    }

    @Override
    protected void statementExecuteBefore(StatementProxy statement, String sql) {
        statement.setLastExecuteStartNano();
    }

    @Override
    protected void statementExecuteBatchBefore(StatementProxy statement) {
        statement.setLastExecuteStartNano();
    }

    @Override
    protected void statementExecuteUpdateBefore(StatementProxy statement, String sql) {
        statement.setLastExecuteStartNano();
    }

    @Override
    protected void statementExecuteQueryBefore(StatementProxy statement, String sql) {
        statement.setLastExecuteStartNano();
    }

    @Override
    protected void statementExecuteAfter(StatementProxy statement, String sql, boolean firstResult) {
        statement.setLastExecuteTimeNano();
    }

    @Override
    protected void statementExecuteBatchAfter(StatementProxy statement, int[] result) {
        statement.setLastExecuteTimeNano();
    }

    @Override
    protected void statementExecuteQueryAfter(StatementProxy statement, String sql, ResultSetProxy resultSet) {
        statement.setLastExecuteTimeNano();
    }

    @Override
    protected void statementExecuteUpdateAfter(StatementProxy statement, String sql, int updateCount) {
        statement.setLastExecuteTimeNano();
    }

    @Override
    public void statement_close(FilterChain chain, StatementProxy statement) throws SQLException {
        super.statement_close(chain, statement);
        // 支持动态开启
        if (!mybatisProperties.isShowSql()) {
            return;
        }

        // 是否开启调试
        if (!log.isInfoEnabled()) {
            return;
        }
        // 如果当前执行sql有结果则不执行 或者是新增语句，因为有id返回也不执行
//        Token token = new SQLStatementParser(statement.getLastExecuteSql()).getExprParser().getLexer().token();
//        if (statement.isFirstResultSet() || token.equals(Token.INSERT)) {
//            return;
//        }
        // 防止有结果时打印两次sql语句
        if (!STATEMENT_CLOSE_RUN) {
            STATEMENT_CLOSE_RUN = true;
            return;
        }
        // 打印可执行的 sql
        String sql = statement.getBatchSql();
        // sql 为空直接返回
        if (StringUtils.isEmpty(sql)) {
            return;
        }
        String executeSql = statement(statement);
        log.info(executeSql);
    }

    public String statement(StatementProxy statement) {
        // 打印可执行的 sql
        String sql = statement.getBatchSql();
        // sql 为空直接返回
        if (StringUtils.isEmpty(sql)) {
            return "";
        }
        int parametersSize = statement.getParametersSize();
        List parameters = new ArrayList<>(parametersSize);
        for (int i = 0; i < parametersSize; ++i) {
            // 转换参数，处理 java8 时间
            parameters.add(getJdbcParameter(statement.getParameter(i)));
        }
        String dbType = statement.getConnectionProxy().getDirectDataSource().getDbType();
        String formattedSql = SQLUtils.format(sql, DbType.of(dbType), parameters, FORMAT_OPTION);
        return printSql(formattedSql, statement);
    }

    private static Object getJdbcParameter(JdbcParameter jdbcParam) {
        if (jdbcParam == null) {
            return null;
        }
        Object value = jdbcParam.getValue();
        // 处理 java8 时间
        if (value instanceof TemporalAccessor) {
            return value.toString();
        }
        return value;
    }

    private static String printSql(String sql, StatementProxy statement) {
        // 打印 sql
        String sqlLogger = "\n--------------------------------[ %s Sql Log ]---------------------------------" + "\n%s" + "\n--------------------------------[ Sql Execute Time: %s  ]---------------------------------\n";
        return String.format(sqlLogger, LocalDateTime.now().format(DateTimeFormatter.ofPattern(DateConstant.NORM_DATETIME_PATTERN)), sql.trim(), format(statement.getLastExecuteTimeNano()));
    }

    /**
     * 格式化执行时间，单位为 ms 和 s，保留三位小数
     *
     * @param nanos 纳秒
     * @return 格式化后的时间
     */
    private static String format(long nanos) {
        if (nanos < 1) {
            return "0ms";
        }
        double millis = (double) nanos / (1000 * 1000);
        // 不够 1 ms，最小单位为 ms
        if (millis > 1000) {
            return String.format("%.3fs", millis / 1000);
        } else {
            return String.format("%.3fms", millis);
        }
    }

    @Override
    public boolean resultSet_next(FilterChain chain, ResultSetProxy resultSet) throws SQLException {
        boolean next = super.resultSet_next(chain, resultSet);
        // 支持动态开启
        if (!mybatisProperties.isShowSql()) {
            return next;
        }

        // 是否开启调试
        if (!log.isInfoEnabled()) {
            return next;
        }
        if (!next) {
            String querySql = statement(resultSet.getStatementProxy());
            String sqlLogger = querySql + "{}" + "--------------------------------[ Results Total {} ]---------------------------------\n";
            String results = "";
            if (rowList.size() > 0) {
                results = TableConsoleUtil.printResult(rowList);
            }
            log.info(sqlLogger, results, rows);
            rows = 0;
            rowList = new LinkedList<>();
            first = true;
            STATEMENT_CLOSE_RUN = false;
            return false;
        }
        STATEMENT_CLOSE_RUN = true;
        rows++;
        rs = resultSet.getResultSetRaw();
        ResultSetMetaData rsmd = resultSet.getMetaData();
        final int columnCount = rsmd.getColumnCount();
        if (first) {
            first = false;
            printColumnHeaders(rsmd, columnCount);
        }
        printColumnValues(columnCount);
        return true;
    }

    private void printColumnHeaders(ResultSetMetaData rsmd, int columnCount) throws SQLException {
        StringJoiner row = new StringJoiner(",");
        for (int i = 1; i <= columnCount; i++) {
            if (BLOB_TYPES.contains(rsmd.getColumnType(i))) {
                blobColumns.add(i);
            }
            row.add(rsmd.getColumnLabel(i));
        }
        rowList.add(row.toString());
    }

    private void printColumnValues(int columnCount) {
        StringJoiner row = new StringJoiner(",");
        for (int i = 1; i <= columnCount; i++) {
            try {
                if (blobColumns.contains(i)) {
                    row.add("<>");
                } else {
                    row.add(rs.getString(i));
                }
            } catch (SQLException e) {
                // generally can't call getString() on a BLOB column
                row.add("<>");
            }
        }
        rowList.add(row.toString());
    }
}

将结果格式化为表格形式的工具代码

目前因为查询出的结果包含中文汉字，为了尽可能整齐，只是默认取了一个汉字为1.5倍的其他字符。有兴趣的自己修改成根据字体、字号获取实际的宽度并生成表格。

package cn.allbs.mybatis.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;

/**
 * 类 TableConsoleUtil
 * 
 *
 * @author ChenQi
 * @since 2023/3/24 13:45
 */
public class TableConsoleUtil {

    public static String printResult(List rows) {
        StringBuilder sb = new StringBuilder();
        String[] tempA = rows.get(0).split(",");
        int maxLen = tempA.length;
        for (int i = 1; i < rows.size(); i++) {
            tempA = rows.get(i).split(",");
            if (maxLen < tempA.length) maxLen = tempA.length;
        }
        String[][] row = new String[rows.size()][maxLen];
        for (int i = 0; i < row.length; i++)
            for (int j = 0; j < row[0].length; j++)
                row[i][j] = "";
        for (int i = 0; i < rows.size(); i++) {
            tempA = rows.get(i).split(",");
            System.arraycopy(tempA, 0, row[i], 0, tempA.length);
        }
        int[] maxJ = new int[maxLen];
        for (int j = 0; j < maxLen; j++) {
            for (int i = 0; i < rows.size(); i++) {
                int vLen = (getWordCount(row[i][j]) - 1 >> 3) * 8 + 8;
                if (vLen > maxJ[j]) {
                    maxJ[j] = vLen;
                }
            }
        }
        StringBuilder opera = new StringBuilder("+");
        for (int value : maxJ) {
            for (int k = 0; k < value; k++) {
                opera.append('-');

            }
            opera.append('+');
        }
        boolean first = true;
        for (String[] strings : row) {
            if (first) {
                sb.append(opera);
                sb.append("\n");
            }
            sb.append("|");
            for (int j = 0; j < row[0].length; j++) {
                int len = maxJ[j] - getWordCount(strings[j]);
                String format;
                if (len == 0) {
                    format = "" + "%s";
                } else {
                    format = "%" + len + "s";
                }
                sb.append(strings[j]);
                sb.append(String.format(format, ""));
                sb.append("|");
            }
            sb.append("\n");
            if (first) {
                sb.append(opera);
                sb.append("\n");
                first = false;
            }
        }
        sb.append(opera);
        sb.append("\n");
        return sb.toString();
    }

    public static int getWordCount(String s) {
        int length = 0;
        int chineseNum = 0;
        for (int i = 0; i < s.length(); i++) {
            int ascii = Character.codePointAt(s, i);
            if (ascii >= 0 && ascii <= 255) length++;
            else chineseNum++;

        }
        return BigDecimal.valueOf(length + chineseNum * 1.5).setScale(0, RoundingMode.HALF_UP).intValue();
    }
}

注册过滤器

@Bean
public DruidSqlLogFilter sqlLogFilter(MybatisProperties properties) {
    return new DruidSqlLogFilter(properties);
}

添加了配置开关当前日志打印效果

@Data
@Component
@ConfigurationProperties("mybatis-plus")
public class MybatisProperties {

    /**
     * 是否打印可执行 sql
     */
    private boolean showSql = true;
}

使用说明

需要将mybatis实现的日志打印注释，防止和本文打印的日志重复。同时将show-sql设置为true。如果生产环境不需要日志打印将其设置为false即可。

实际使用示例

查询

新增

返回值为插入数据的主键

更新

删除

因为使用逻辑删除所以是更新语句

移出逻辑删除后

xml中的自定义sql

SFJK-200 可燃气体控制器 MODBUS 通讯协议

2023-03-10T02:25:00.000Z

工具包引入

<dependency>
  <groupId>cn.allbsgroupId>
  <artifactId>allbs-modelartifactId>
  <version>0.6.0version>
dependency>

源码下载

引用站外地址

解析工具的源码下载

github

解析&生成过程中自定义参数说明

应用场景	参数值	参数说明
指令生成	`GeneratorEnum`.`ADDRESS`.name	从站地址
指令生成	`GeneratorEnum`.`FUNCTION`.name	功能码
指令生成	`GeneratorEnum`.`START_ADDRESS`.name	起始寄存器地址
指令生成	`GeneratorEnum`.`READ_ADDRESS`.name	读寄存器地址
协议解析	`data`	数据信息
协议解析	`circuit`	回路
协议解析	`point`	点数
协议解析	`gas_type`	点位属性
协议解析	`pre_gas_type`	点位属性原始值
协议解析	`gas_unit`	气体单位
协议解析	`pre_gas_unit`	气体单位原始值
协议解析	`gas_num`	气体监测值
协议解析	`detector_status`	探测器状态
协议解析	`pre_detector_status`	探测器状态原始值
协议解析	`detector_num`	探测器浓度值
协议解析	`extra_power`	外控电源状态
协议解析	`pre_extra_power`	外控电源状态原始值
协议解析	`address`	地址
协议解析	`function`	功能
协议解析	`controller_status`	控制器状态
协议解析	`pre_controller_status`	控制器状态原始值

生成示例

代码

Map map = new HashMap<>(4);
// 地址
map.put(ADDRESS.getName(), 1);
// 功能码
map.put(FUNCTION.getName(), 3);
// 起始寄存器地址
map.put(START_ADDRESS.getName(), 0);
// 读寄存器数量
map.put(READ_ADDRESS.getName(), 2);
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
byte[] bytes = sfjk200Mapper.writeDataAsByteArray(map);

结果

解析示例

读取 SFJK-200 控制器配置点数( 未配置点数时，返回回路 x 的值为 0x00 )所有请求数据及响应数据均以 16 进制数据进行交换

byte[] bytes = new byte[9];
bytes[0] = 0x01;
bytes[1] = 0x03;
bytes[2] = 0x04;
bytes[3] = 0x3F;
bytes[4] = 0x00;
bytes[5] = 0x00;
bytes[6] = 0x00;
bytes[7] = (byte) 0xf6;
bytes[8] = 0x27;
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
System.out.println(sfjk200Mapper.readValue(bytes, 0x0000, Map.class));

读取探测器属性及单位 ( 读取 1 回路 1 号点探测的浓度及属性，根据寄存器地址映射表查到，1 号探测器对应寄存器地址为 0002H )数据高字节代表单位，低字节代表属性。

byte[] bytes = new byte[9];
bytes[0] = 0x01;
bytes[1] = 0x03;
bytes[2] = 0x02;
bytes[3] = 0x01;
bytes[4] = 0x0A;
bytes[5] = (byte) 0x39;
bytes[6] = (byte) 0xD3;
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
System.out.println(sfjk200Mapper.readValue(bytes, 0x0002, Map.class));

连续读取 1 回路 3、4、5、6 号探测器属性及单位。（根据寄存器地址映射表查到 3 号探测器从 0004H 地址开始）

byte[] bytes = new byte[13];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x08;
bytes[3] = (byte) 0x01;
bytes[4] = (byte) 0x0A;
bytes[5] = (byte) 0x01;
bytes[6] = (byte) 0x0D;
bytes[7] = (byte) 0x00;
bytes[8] = (byte) 0x81;

bytes[9] = (byte) 0x02;
bytes[10] = (byte) 0x82;
bytes[11] = (byte) 0x03;
bytes[12] = (byte) 0x22;
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x0004, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

读取 1 回路 1 号探测器的低限报警值( 假设 1 号探测器属性为甲烷，单位为%LEL.根据寄存器地址映射表查到，1 号探测器对应寄存器地址为 03E2H)

byte[] bytes = new byte[7];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;

bytes[2] = (byte) 0x02;
bytes[3] = (byte) 0x00;
bytes[4] = (byte) 0xFA;
bytes[5] = (byte) 0x38;
bytes[6] = (byte) 0x07;
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x03E2, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

** 注意:当前数据为全部除以10后的数据，因为解析和指令是分开的，所以需要根据指定中指定气体单位判断返回结果需不需要乘以10 **

读取 1 回路 3、4、5、6 号探测器的低限报警值（3 号点属性为天然气，单位为%LEL .4 号点为甲烷，单位为%LEL .5 号点属性为一氧化碳，单位为 μmol/mol，6 号点为氧气，单位为%V/V）根据寄存器地址映射表查到，3 号探测器对应寄存器地址为 03E4H

byte[] bytes = new byte[13];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x08;

bytes[3] = (byte) 0x00;
bytes[4] = (byte) 0x64;
bytes[5] = (byte) 0x00;
bytes[6] = (byte) 0x96;
bytes[7] = (byte) 0x00;
bytes[8] = (byte) 0x78;

bytes[9] = (byte) 0x00;
bytes[10] = (byte) 0xBD;
bytes[11] = (byte) 0xB8;
bytes[12] = (byte) 0x64;
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x03E4, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

** 注意:当前数据为全部除以10后的数据，因为解析和指令是分开的，所以需要根据指定中指定气体单位判断返回结果需不需要乘以10 **

读取单个探测器状态（状态参考探测器状态定义）根据寄存器地址映射表查到，1 号探测器对应寄存器地址为 07C2H

示例

代码

byte[] bytes = new byte[7];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x02;

bytes[3] = (byte) 0x00;
bytes[4] = (byte) 0x01;
bytes[5] = (byte) 0x79;
bytes[6] = (byte) 0x8E;
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x07C2, Map.class);
map.forEach((k, v) -> {
if (k.equals("data")) {
    List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

输出

** 示例CRC存在问题 **

读取 1 回路 3、4、5、6 号探测器的状态（根据寄存器地址映射表查到，3 号探测器对应寄存器地址为 07C4H）

示例

代码

byte[] bytes = new byte[13];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x08;

bytes[3] = (byte) 0x00;
bytes[4] = (byte) 0x01;
bytes[5] = (byte) 0x00;
bytes[6] = (byte) 0x03;

bytes[7] = (byte) 0x00;
bytes[8] = (byte) 0x04;
bytes[9] = (byte) 0x00;
bytes[10] = (byte) 0x08;
bytes[11] = (byte) 0x81;
bytes[12] = (byte) 0x10;
SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x07C4, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

输出

读取 1 回路 1 号点探测器的当前浓度值（根据寄存器地址映射表查到，1 号探测器对应寄存器地址为 0BA2H ）

byte[] bytes = new byte[7];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x02;

bytes[3] = (byte) 0x01;
bytes[4] = (byte) 0x5A;
bytes[5] = (byte) 0x39;
bytes[6] = (byte) 0xEF;

SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x0BA2, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

** 注意:当前数据为全部除以10后的数据，因为解析和指令是分开的，所以需要根据指定中指定气体单位判断返回结果需不需要乘以10 **

读取 1 回路 3、4、5、6 号探测器的低限报警值（3 号点属性为天然气，单位为%LEL .4 号点为甲烷，单位为%LEL .5 号点属性为一氧化碳，单位为 μmol/mol，6 号点为氧气，单位为%V/V）根据寄存器地址映射表查到，3 号探测器对应寄存器地址为 0BA4H

byte[] bytes = new byte[13];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x08;

bytes[3] = (byte) 0x00;
bytes[4] = (byte) 0x64;
bytes[5] = (byte) 0x00;
bytes[6] = (byte) 0x96;

bytes[7] = (byte) 0x01;
bytes[8] = (byte) 0x40;
bytes[9] = (byte) 0x00;
bytes[10] = (byte) 0xD1;
bytes[11] = (byte) 0x38;
bytes[12] = (byte) 0x78;

SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x03E4, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

读取 SFJK-200 外控电源状态( 外控电源状态请参考外控电压状态定义表 ) 1 回路外控电源对应寄存器地址为 0f82H ）

byte[] bytes = new byte[9];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x04;

bytes[3] = (byte) 0x30;
bytes[4] = (byte) 0x30;
bytes[5] = (byte) 0x30;
bytes[6] = (byte) 0x30;

bytes[7] = (byte) 0xE1;
bytes[8] = (byte) 0x28;

SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x0F82, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

读取 SFJK-200 控制器状态(SFJK-200 控制器状态参考控制器状态定义表 ) 根据寄存器地址映射表查到，对应寄存器地址为 0F8AH

byte[] bytes = new byte[7];
bytes[0] = (byte) 0x01;
bytes[1] = (byte) 0x03;
bytes[2] = (byte) 0x02;

bytes[3] = (byte) 0x00;
bytes[4] = (byte) 0x01;
bytes[5] = (byte) 0x79;
bytes[6] = (byte) 0x8E;

SFJK200Mapper sfjk200Mapper = new SFJK200Mapper();
Map map = sfjk200Mapper.readValue(bytes, 0x0F8A, Map.class);
map.forEach((k, v) -> {
    if (k.equals("data")) {
        List> list = (List>) v;
        list.forEach(System.out::println);
    } else {
        System.out.println(k + ":" + v);
    }
});

** 示例中的CRC校验错误 **

模拟读写

使用工具modbus slave工具

保存至influxdb结果

下载modbus slave测试内容

Mbslave1.mbs Mbslave2.mbs Mbslave3.mbs Mbslave4.mbs Mbslave5.mbs Mbslave6.mbs Mbslave7.mbs

最后是使用的java开发的示例demo

引用站外地址

demo下载

github

GB26875 城市消防远程监控通讯协议解析

2023-03-02T01:25:00.000Z

工具包引入

<dependency>
  <groupId>cn.allbsgroupId>
  <artifactId>allbs-modelartifactId>
  <version>0.8.2version>
dependency>

源码下载

引用站外地址

源码下载

github

解析字段说明

字段值	字段说明
`sysType`	系统类型标志
`sysTypeTrans`	系统类型标志含义
`sysAddress`	系统地址
`sysDesc`	系统状态
`partType`	部件类型
`partTypeTrans`	部件类型翻译
`partAddress`	部件地址
`partDesc`	部件状态
`partExplain`	部件说明
`time`	时间
`aq`	模拟量类型
`aqNum`	模拟量值
`operateType`	操作员标识
`operatorNum`	操作员编号
`mainVersion`	主版本号
`minorVersion`	次版本号
`sysConfLen`	系统配置说明长度
`sysConfExplain`	系统配置说明内容
`runningStatus`	运行状态
`transmittingConfLen`	系统配置说明长度
`transmittingConfExplain`	系统配置说明内容
`msgData`	信息对象
`msgDataType`	数据单元标识符-类型标志
`msgDataTypeTrans`	数据单元标识符-类型标志
`msgDataNum`	数据单元标识符-信息对象数目
`flow`	流水号
`sourceAddress`	源地址
`targetAddress`	目的地址
`controlOrder`	控制命令
`data`	应用数据单元
`happenTime`	时间

解析示例

代码示例

byte[] bytes = new byte[34];
bytes[0] = 0x40;
bytes[1] = 0x40;
bytes[2] = 0x76;
bytes[3] = 0x31;
bytes[4] = 0x1;
bytes[5] = 0x2;
bytes[6] = 0xc;
bytes[7] = 0xf;
bytes[8] = 0x0;
bytes[9] = 0xb;
bytes[10] = 0x7;
bytes[11] = 0x16;
bytes[12] = 0x50;
bytes[13] = 0x0;
bytes[14] = 0x0;
bytes[15] = 0x0;
bytes[16] = 0x0;
bytes[17] = 0x0;
bytes[18] = 0x3c;
bytes[19] = (byte) 0xce;
bytes[20] = (byte) 0xb5;
bytes[21] = 0x6a;
bytes[22] = 0x8;
bytes[23] = 0x0;
bytes[24] = 0x4;
bytes[25] = 0x0;
bytes[26] = 0x2;
bytes[27] = 0x19;
bytes[28] = 0x1;
bytes[29] = 0x1;
bytes[30] = 0x1;
bytes[31] = (byte) 0x90;
bytes[32] = 0x23;
bytes[33] = 0x23;
GB26875Mapper gb26875Mapper = new GB26875Mapper();
Map map = gb26875Mapper.readValue(bytes, Map.class);
map.forEach((k, v) -> {
    System.out.println(k + ":" + v);
});

结果示例

JBF293K 通讯接口卡 RS232/485 通讯协议解析

2023-02-24T02:25:00.000Z

工具包引入

<dependency>
  <groupId>cn.allbsgroupId>
  <artifactId>allbs-modelartifactId>
  <version>0.4.0version>
dependency>

源码下载

引用站外地址

源码下载

github

解析字段说明

字段值	字段说明
`machineNo`	机器号
`time`	时间
`version`	版本号
`order`	命令-中文说明
`preOrder`	命令-原始值
`code`	代码
`controller`	控制器
`message`	信息类型-中文说明
`preMessage`	信息类型-原始值
`circuit`	回路
`part`	部位
`disk`	盘号
`district`	区号
`boardNumber`	板号
`line`	专线号
`address`	地址
`type`	部件类型-中文说明
`preType`	部件类型-原始值
`status`	状态
`preStatus`	状态
`sensorChannel`	传感器通道
`alarmValue`	报警值
`accumulateSum`	累加和
`unit`	单位

心跳报文解析

报文解析示例

示例代码

byte[] bytes = new byte[26];
bytes[0] = (byte) 0x82;
bytes[1] = (byte) 0x30;
bytes[2] = (byte) 0x30;
bytes[3] = (byte) 0x32;
bytes[4] = (byte) 0x34;
bytes[5] = (byte) 0x30;
bytes[6] = (byte) 0x30;
bytes[7] = (byte) 0x30;
bytes[8] = (byte) 0x30;
bytes[9] = (byte) 0x30;
bytes[10] = (byte) 0x30;
bytes[11] = (byte) 0x31;
bytes[12] = (byte) 0x31;
bytes[13] = (byte) 0x30;
bytes[14] = (byte) 0x35;
bytes[15] = (byte) 0x31;
bytes[16] = (byte) 0x38;
bytes[17] = (byte) 0x30;
bytes[18] = (byte) 0x3E;
bytes[19] = (byte) 0x30;
bytes[20] = (byte) 0x3F;
bytes[21] = (byte) 0x31;
bytes[22] = (byte) 0x31;
bytes[23] = (byte) 0x38;
bytes[24] = (byte) 0x30;
bytes[25] = (byte) 0x83;
JBF293KMapper jbf293KMapper = new JBF293KMapper();
System.out.println(jbf293KMapper.readValue(bytes, Map.class));

结果图

正常应答数据

报文解析示例

示例代码

byte[] bytes = new byte[26];
// 报文头
bytes[0] = (byte) 0x82;
// D1
bytes[1] = (byte) 0x30;
bytes[2] = (byte) 0x39;
// D2
bytes[3] = (byte) 0x30;
bytes[4] = (byte) 0x31;
// D3
bytes[5] = (byte) 0x30;
bytes[6] = (byte) 0x30;
// D4
bytes[7] = (byte) 0x30;
bytes[8] = (byte) 0x30;
// D5
bytes[9] = (byte) 0x30;
bytes[10] = (byte) 0x30;
// D6
bytes[11] = (byte) 0x30;
bytes[12] = (byte) 0x30;
// D7
bytes[13] = (byte) 0x30;
bytes[14] = (byte) 0x30;
// D8
bytes[15] = (byte) 0x30;
bytes[16] = (byte) 0x30;
// D9
bytes[17] = (byte) 0x30;
bytes[18] = (byte) 0x30;
// D10
bytes[19] = (byte) 0x30;
bytes[20] = (byte) 0x30;
// D11
bytes[21] = (byte) 0x30;
bytes[22] = (byte) 0x30;
// D12
bytes[23] = (byte) 0x30;
bytes[24] = (byte) 0x3A;
// 报文尾
bytes[25] = (byte) 0x83;
JBF293KMapper jbf293KMapper = new JBF293KMapper();
System.out.println(jbf293KMapper.readValue(bytes, Map.class));

结果图

火警数据报文解析

报文解析示例

代码示例

byte[] bytes = new byte[26];
// 报文头
bytes[0] = (byte) 0x82;
// D1
bytes[1] = (byte) 0x38;
bytes[2] = (byte) 0x30;
// D2
bytes[3] = (byte) 0x32;
bytes[4] = (byte) 0x34;
// D3
bytes[5] = (byte) 0x30;
bytes[6] = (byte) 0x38;
// D4
bytes[7] = (byte) 0x39;
bytes[8] = (byte) 0x3B;
// D5
bytes[9] = (byte) 0x30;
bytes[10] = (byte) 0x31;
// D6
bytes[11] = (byte) 0x31;
bytes[12] = (byte) 0x31;
// D7
bytes[13] = (byte) 0x30;
bytes[14] = (byte) 0x33;
// D8
bytes[15] = (byte) 0x30;
bytes[16] = (byte) 0x38;
// D9
bytes[17] = (byte) 0x31;
bytes[18] = (byte) 0x30;
// D10
bytes[19] = (byte) 0x30;
bytes[20] = (byte) 0x34;
// D11
bytes[21] = (byte) 0x30;
bytes[22] = (byte) 0x38;
// D12
bytes[23] = (byte) 0x38;
bytes[24] = (byte) 0x30;
// 报文尾
bytes[25] = (byte) 0x83;
JBF293KMapper jbf293KMapper = new JBF293KMapper();
System.out.println(jbf293KMapper.readValue(bytes, Map.class));

结果示例

喷洒启动

报文解析示例

代码示例

byte[] bytes = new byte[26];
// 报文头
bytes[0] = (byte) 0x82;
// D1
bytes[1] = (byte) 0x3F;
bytes[2] = (byte) 0x3A;
// D2
bytes[3] = (byte) 0x30;
bytes[4] = (byte) 0x32;
// D3
bytes[5] = (byte) 0x30;
bytes[6] = (byte) 0x3B;
// D4
bytes[7] = (byte) 0x30;
bytes[8] = (byte) 0x32;
// D5
bytes[9] = (byte) 0x30;
bytes[10] = (byte) 0x32;
// D6
bytes[11] = (byte) 0x31;
bytes[12] = (byte) 0x31;
// D7
bytes[13] = (byte) 0x30;
bytes[14] = (byte) 0x33;
// D8
bytes[15] = (byte) 0x30;
bytes[16] = (byte) 0x39;
// D9
bytes[17] = (byte) 0x30;
bytes[18] = (byte) 0x3E;
// D10
bytes[19] = (byte) 0x30;
bytes[20] = (byte) 0x3D;
// D11
bytes[21] = (byte) 0x31;
bytes[22] = (byte) 0x3B;
// D12
bytes[23] = (byte) 0x35;
bytes[24] = (byte) 0x3E;
// 报文尾
bytes[25] = (byte) 0x83;
JBF293KMapper jbf293KMapper = new JBF293KMapper();
System.out.println(jbf293KMapper.readValue(bytes, Map.class));

结果示例

单常开防火门故障

报文解析示例(文档累加和错误)

代码示例

byte[] bytes = new byte[26];
// 报文头
bytes[0] = (byte) 0x82;
// D1
bytes[1] = (byte) 0x3F;
bytes[2] = (byte) 0x3B;
// D2
bytes[3] = (byte) 0x32;
bytes[4] = (byte) 0x34;
// D3
bytes[5] = (byte) 0x30;
bytes[6] = (byte) 0x31;
// D4
bytes[7] = (byte) 0x3F;
bytes[8] = (byte) 0x3E;
// D5
bytes[9] = (byte) 0x31;
bytes[10] = (byte) 0x31;
// D6
bytes[11] = (byte) 0x31;
bytes[12] = (byte) 0x31;
// D7
bytes[13] = (byte) 0x30;
bytes[14] = (byte) 0x33;
// D8
bytes[15] = (byte) 0x31;
bytes[16] = (byte) 0x37;
// D9
bytes[17] = (byte) 0x30;
bytes[18] = (byte) 0x37;
// D10
bytes[19] = (byte) 0x30;
bytes[20] = (byte) 0x37;
// D11
bytes[21] = (byte) 0x31;
bytes[22] = (byte) 0x3F;
// D12
bytes[23] = (byte) 0x3A;
bytes[24] = (byte) 0x37;
// 报文尾
bytes[25] = (byte) 0x83;
JBF293KMapper jbf293KMapper = new JBF293KMapper();
System.out.println(jbf293KMapper.readValue(bytes, Map.class));

结果示例

剩余电流探测器故障

报文示例

代码示例

byte[] bytes = new byte[26];
// 报文头
bytes[0] = (byte) 0x82;
// D1
bytes[1] = (byte) 0x3F;
bytes[2] = (byte) 0x3C;
// D2
bytes[3] = (byte) 0x32;
bytes[4] = (byte) 0x34;
// D3
bytes[5] = (byte) 0x32;
bytes[6] = (byte) 0x30;
// D4
bytes[7] = (byte) 0x3C;
bytes[8] = (byte) 0x37;
// D5
bytes[9] = (byte) 0x32;
bytes[10] = (byte) 0x32;
// D6
bytes[11] = (byte) 0x31;
bytes[12] = (byte) 0x31;
// D7
bytes[13] = (byte) 0x30;
bytes[14] = (byte) 0x34;
// D8
bytes[15] = (byte) 0x31;
bytes[16] = (byte) 0x37;
// D9
bytes[17] = (byte) 0x30;
bytes[18] = (byte) 0x37;
// D10
bytes[19] = (byte) 0x30;
bytes[20] = (byte) 0x37;
// D11
bytes[21] = (byte) 0x31;
bytes[22] = (byte) 0x3F;
// D12
bytes[23] = (byte) 0x38;
bytes[24] = (byte) 0x32;
// 报文尾
bytes[25] = (byte) 0x83;
JBF293KMapper jbf293KMapper = new JBF293KMapper();
System.out.println(jbf293KMapper.readValue(bytes, Map.class));

结果示例

温度探测器

报文示例（文档中报文crc校验值错误）

代码示例

byte[] bytes = new byte[36];
// 报文头
bytes[0] = (byte) 0x82;
// D1
bytes[1] = (byte) 0x3F;
bytes[2] = (byte) 0x3C;
// D2
bytes[3] = (byte) 0x30;
bytes[4] = (byte) 0x32;
// D3
bytes[5] = (byte) 0x30;
bytes[6] = (byte) 0x31;
// D4
bytes[7] = (byte) 0x34;
bytes[8] = (byte) 0x32;
// D5
bytes[9] = (byte) 0x3F;
bytes[10] = (byte) 0x3F;
// D6
bytes[11] = (byte) 0x31;
bytes[12] = (byte) 0x31;
// D7
bytes[13] = (byte) 0x30;
bytes[14] = (byte) 0x35;
// D8
bytes[15] = (byte) 0x31;
bytes[16] = (byte) 0x38;
// D9
bytes[17] = (byte) 0x30;
bytes[18] = (byte) 0x3F;
// D10
bytes[19] = (byte) 0x32;
bytes[20] = (byte) 0x3D;
// D11
bytes[21] = (byte) 0x30;
bytes[22] = (byte) 0x31;
// D12
bytes[23] = (byte) 0x3A;
bytes[24] = (byte) 0x3B;
// D13
bytes[25] = (byte) 0x31;
bytes[26] = (byte) 0x33;
// D14
bytes[27] = (byte) 0x30;
bytes[28] = (byte) 0x30;
// D15
bytes[29] = (byte) 0x35;
bytes[30] = (byte) 0x38;
// D16
bytes[31] = (byte) 0x30;
bytes[32] = (byte) 0x32;
// CRC
bytes[33] = (byte) 0x3E;
bytes[34] = (byte) 0x33;
// 报文尾
bytes[35] = (byte) 0x83;
JBF293KMapper jbf293KMapper = new JBF293KMapper();
System.out.println(jbf293KMapper.readValue(bytes, Map.class));

结果示例

调试过程

设备接线

配置设备网络地址和串口

使用串口工具模拟发送报文

引用站外地址

串口调试工具

nas

启动java服务接收数据

java程序调用dll

2023-02-06T08:53:00.000Z

项目需求

调用捷宸EIO开发包DLL动态库控制应急门的开关停，现场应急门继电器连接的是6、7、8，分别对应的是开、停、关。0为打开，1为关闭。

java程序开发

在resource中新建lib将dll放入其中

sdk工具开发

package com.lyc.ocr.door;

import com.sun.jna.Library;
import com.sun.jna.Native;
public interface DoorCallSDK extends Library {

    DoorCallSDK INSTANCE = (DoorCallSDK) Native.loadLibrary("IOSDK_x64", DoorCallSDK.class);

    /**
     * 创建设备
     * 
     * 以IP 地址为参数，创建一个设备
     *
     * @param strIp ansi 字符串，设备 IP 地址 如"192.168.1
     * @return 0 表示创建设备失败，非 0 成功；表示"设备句柄"
     */
    int Jc_CreateDev(String strIp);

    /**
     * 登录（解锁）设备
     *
     * @param lDev   设备句柄
     * @param strPwd ansi 字符串 表示设备登录（解锁）密
     * @return 成功：0，失败：非零
     */
    int Jc_LoginDev(int lDev, String strPwd);

    /**
     * 删除（释放）设备
     * 
     * 释放不再需要使用的设备
     *
     * @param lDev 设备句柄
     */
    void Jc_DelDev(int lDev);

    /**
     * 创建通讯设备（通过串口）
     *
     * @param btAddr     modbus 地址
     * @param btWorkType 工作模式 （0：TcpServer，1：TCPClient，2：UDP）
     * @param btProtocol 协议类型 ( 0:Modbus_rtu , 1:modbus_Tcp
     * @param uLocalPort 本地端口
     * @param pDevIp     设备 ip 地址
     * @param uDevPort   设备通讯端口
     * @return 成功：非零值，失败：0
     */
    int Jc_CreateNetComuDev(byte btAddr, byte btWorkType, byte btProtocol, short uLocalPort, String pDevIp, short uDevPort);

    /**
     * 判断是否已经连接到模块
     *
     * @param hDev 连接句柄（前面两种方式任意一种创建通讯设备）
     * @return 成功：true，失败：false
     */
    boolean Jc_IsDevConnected(int hDev);

    /**
     * 读取 IO 状态
     *
     * @param hDev  设备句柄
     * @param strIo 16 个字节的缓冲区，每一个字节代表一个 io 状态 ‘0’:低 ‘1’:高
     * @return 成功：0，失败：非零
     */
    int Jc_GetIoState(int hDev, byte[] strIo);

    /**
     * 设置 IO 状态
     *
     * @param hDev  设备句柄
     * @param strIo 16 个字节的缓冲区，每一个字节代表一个 io 状态 ‘0’:低 ‘1’:高
     * @return 成功：0，失败：非零
     */
    int Jc_SetIoState(int hDev, byte[] strIo);

    /**
     * 释放连接
     *
     * @param hDev 连接句柄
     */
    void Jc_ReleaseComuDev(int hDev);
}

为保证达成jar包后能顺利读取到所需要的dll，将dll复制至C:\Windows\System32

提供接口供外部使用

/**
  * 设备通讯
  *
  * @return 是否成功
*/
@PostMapping("doorConn")
public boolean doorCommunication(@RequestBody DoorDTO doorDTO) {
    try {
        DoorCallSDK doorCallSDK = DoorCallSDK.INSTANCE;
        // 连接到IO模块
        int mhCon = doorCallSDK.Jc_CreateNetComuDev(doorDTO.getBtAddr(),
                doorDTO.getBtWorkType(),
                doorDTO.getBtProtocol(),
                doorDTO.getLocalPort(),
                doorDTO.getIp(),
                doorDTO.getDevPort()
        );
        if (mhCon == 0) {
            return false;
        }
        log.info("接口【/door/doorConn】什么什么门连接成功");
        // 读取IO状态
        sdk.Jc_GetIoState(mhCon, doorDTO.getMbtIoState());
        // 修改某个IO口的状态
        //            doorDTO.setMbtIoState();
        // 同步到设备中
        sdk.Jc_SetIoState(mhCon, doorDTO.getMbtIoState());
        // 释放连接
        sdk.Jc_ReleaseComuDev(mhCon);
    } catch (Exception e) {
        return false;
    } catch (UnsatisfiedLinkError error) {
        log.error("接口设备什么什么门通信连接失败");
        return false;
    }
    return true;
}

调用测试

后续

捷宸反馈dll调用的文档过时了，重新发了一份IO连接demo过来，实现一个netty客户端达到应急门控制的目的

NettyClient

package com.lyc.ocr.client;

import cn.hutool.core.convert.Convert;
import com.lyc.ocr.client.handler.NettyClientHandlerInitializer;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class NettyClient {

    /**
     * 重连频率，单位：秒
     */
    private static final Integer RECONNECT_SECONDS = 20;

    @Autowired
    private NettyClientHandlerInitializer nettyClientHandlerInitializer;

    private static int[] g_McRctable_16 =
            {
                    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
                    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
                    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
                    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
                    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
                    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
                    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
                    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
                    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
                    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
                    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
                    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
                    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
                    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
                    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
                    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
                    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
                    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
                    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
                    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
                    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
                    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
                    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
                    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
                    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
                    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
                    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
                    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
                    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
                    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
                    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
                    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
            };

    /**
     * 线程组，用于客户端对服务端的链接、数据读写
     */
    private EventLoopGroup eventGroup = new NioEventLoopGroup();

    /**
     * 用于保存channel通道
     */
    private static final Map CHANNEL_MAP = new ConcurrentHashMap<>();

    /**
     * 保存用户需要重连的地址信息
     */
    private static final Set CONNECT_LIST = new HashSet<>();

    public void reconnect() {
        eventGroup.schedule(() -> {
            log.info("[reconnect][开始重连]");

            CONNECT_LIST.forEach((a) -> {
                try {
                    String[] s = a.split(":");
                    start(s[0], Convert.toInt(s[1]), new byte[]{});
                } catch (InterruptedException e) {
                    log.error("[reconnect][重连失败]", e);
                }
            });

        }, RECONNECT_SECONDS, TimeUnit.SECONDS);
        log.info("[reconnect][{} 秒后将发起重连]", RECONNECT_SECONDS);
    }

    /**
     * 启动 Netty Client
     */
    public void start(String host, Integer port, byte[] content) throws InterruptedException {
        if (CHANNEL_MAP.containsKey(host + ":" + port) && CHANNEL_MAP.get(host + ":" + port) != null) {
            return;
        }
        // 创建 Bootstrap 对象，用于 Netty Client 启动
        Bootstrap bootstrap = new Bootstrap();
        // 设置 Bootstrap 的各种属性。
        bootstrap.group(eventGroup) // 设置一个 EventLoopGroup 对象
                .channel(NioSocketChannel.class)  // 指定 Channel 为客户端 NioSocketChannel
                .remoteAddress(host, port) // 指定链接服务器的地址
                .option(ChannelOption.SO_KEEPALIVE, true) // TCP Keepalive 机制，实现 TCP 层级的心跳保活功能
                .option(ChannelOption.TCP_NODELAY, true) // 允许较小的数据包的发送，降低延迟
                .handler(nettyClientHandlerInitializer);
        // 链接服务器，并异步等待成功，即启动客户端
        bootstrap.connect().addListener(new ChannelFutureListener() {

            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                // 连接失败
                if (!future.isSuccess()) {
                    log.error("[start][Netty Client 连接服务器({}:{}) 失败]", host, port);
                    reconnect();
                    return;
                }
                // 连接成功
                CHANNEL_MAP.put(host + ":" + port, future.channel());
                CONNECT_LIST.add(host + ":" + port);
//                channel = future.channel();
                log.info("[start][Netty Client 连接服务器({}:{}) 成功]", host, port);
                if (content.length > 0) {
                    future.channel().writeAndFlush(content);
                }
            }

        });
    }

    /**
     * 关闭 Netty Server
     */
    @PreDestroy
    public void shutdown() {
        // 关闭 Netty Client
        CHANNEL_MAP.forEach((k, v) -> {
            if (v != null) {
                v.close();
            }
        });
        // 优雅关闭一个 EventLoopGroup 对象
        eventGroup.shutdownGracefully();
    }

    /**
     * 发送消息
     *
     * @param content 消息体
     */
    public void send(String host, Integer port, byte[] content) {
        Channel channel = Optional.of(CHANNEL_MAP).map(a -> a.get(host + ":" + port)).orElse(null);
        if (channel == null) {
            log.error("[send][连接不存在]");
            return;
        }
        if (!channel.isActive()) {
            log.error("[send][连接({})未激活]", channel.id());
            return;
        }
        // 发送消息
        channel.writeAndFlush(content);
    }

    public void remove(ChannelId channelId) {
        CHANNEL_MAP.forEach((k, v) -> {
            if (channelId.equals(v.id())) {
                CHANNEL_MAP.remove(k);
            }
        });
    }

    public int CRC_GetModbus16(byte[] pData, int nLength) {
        int cRc_16 = 0xFFFF;
        byte temp;

        for (int i = 0; i < nLength; ++i) {
            temp = (byte) (cRc_16 & 0xFF);
            cRc_16 = (int) ((cRc_16 >> 8) ^ g_McRctable_16[(temp ^ pData[i]) & 0xFF]);
        }


        return cRc_16;
    }

}

NettyClientHandler

package com.lyc.ocr.client.handler;

import com.lyc.ocr.client.NettyClient;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleStateEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@ChannelHandler.Sharable
public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    @Autowired
    private NettyClient nettyClient;

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        // 发起重连
        nettyClient.reconnect();
        // 继续触发事件
        super.channelInactive(ctx);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        log.error("[exceptionCaught][连接({}) 发生异常]", ctx.channel().id(), cause);
        // 断开连接
        nettyClient.remove(ctx.channel().id());
        ctx.channel().close();
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object event) throws Exception {
        // 空闲时，向服务端发起一次心跳，通过指定命令获取当前服务端应急门状态，使服务端发送应急们状态给当前客户端
        if (event instanceof IdleStateEvent) {
            byte[] sendData = new byte[8];
            sendData[0] = 0x01; //地址码，根据设备地址填写
            sendData[1] = 0x03; //功能码，表示读取
            sendData[2] = 0x00; //起始地址高位
            sendData[3] = 0x01; //起始地址低位
            sendData[4] = 0x00; //要读取的寄存器数量的高位
            sendData[5] = 0x01; //要读取的寄存器数量的低位


            int uCrc = nettyClient.CRC_GetModbus16(sendData, 6);

            sendData[6] = (byte) (uCrc); //crc16校验高位
            sendData[7] = (byte) (uCrc >> 8); //crc16校验低位
            ctx.writeAndFlush(sendData)
                    .addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
        } else {
            super.userEventTriggered(ctx, event);
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 读取服务端信息，防止连接服务端出现ReadTimeOutException
        log.info("Client,接收到服务端发来的消息:" + msg);
    }
}

NettyClientHandlerInitializer

package com.lyc.ocr.client.handler;

import com.lyc.ocr.client.codec.InvocationEncoder;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.handler.timeout.IdleStateHandler;
import io.netty.handler.timeout.ReadTimeoutHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class NettyClientHandlerInitializer extends ChannelInitializer {

    /**
     * 心跳超时时间
     */
    private static final Integer READ_TIMEOUT_SECONDS = 60;

    @Autowired
    private NettyClientHandler nettyClientHandler;

    @Override
    protected void initChannel(Channel ch) {
        ch.pipeline()
                // 空闲检测
                .addLast(new IdleStateHandler(READ_TIMEOUT_SECONDS, 0, 0))
                .addLast(new ReadTimeoutHandler(3 * READ_TIMEOUT_SECONDS))
                // 编码器
                .addLast(new InvocationEncoder())
                // 客户端处理器
                .addLast(nettyClientHandler)
        ;
    }

}

InvocationEncoder

package com.lyc.ocr.client.codec;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

public class InvocationEncoder extends MessageToByteEncoder<byte[]> {
    @Override
    protected void encode(ChannelHandlerContext ctx, byte[] content, ByteBuf out) {
        // 写入内容
        out.writeBytes(content);
    }
}

上面的controller修改

package com.lyc.ocr.controller;

import com.lyc.ocr.client.NettyClient;
import com.lyc.ocr.door.DoorDTO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
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 javax.annotation.Resource;

@Slf4j
@RequestMapping("/door")
@RestController
public class DoorController {

    @Resource
    private NettyClient nettyClient;

    /**
     * 设备通讯
     *
     * @return 是否成功
     */
    @PostMapping("doorConn")
    public boolean doorCommunication(@RequestBody DoorDTO doorDTO) {
        // 发送指令
        String strSet;
        strSet = doorDTO.getMbtIoState().replace(" ", "");

        //置高寄存器值
        int uSetH = 0;
        //置低寄存器值
        int uSetL = 0;

        for (int i = 0; i < 16; i++) {
            String[] ss = strSet.split("");
            if ("1".equals(ss[i])) {
                //把置高寄存器相应的位置成1
                uSetH |= 1 << i;
                //把置低寄存器相应的位置成0
                uSetL &= ~(1 << i);
            } else if ("0".equals(ss[i])) {
                //把置高寄存器相应的位置成0
                uSetH &= ~(1 << i);
                //把置低寄存器相应的位置成1
                uSetL |= 1 << i;
            }
        }

        byte[] sendData = new byte[13];
        sendData[0] = 0x01; //地址码，根据设备地址填写
        sendData[1] = 0x10; //功能码，表示要写多个寄存器
        sendData[2] = 0x00; //起始地址高位
        sendData[3] = 0x02; //起始地址低位
        sendData[4] = 0x00; //寄存器数量高位
        sendData[5] = 0x02; //寄存器数量低位
        sendData[6] = 0x04; //要写的字节数
        sendData[7] = (byte) (uSetH >> 8); //
        sendData[8] = (byte) (uSetH); //
        sendData[9] = (byte) (uSetL >> 8); //
        sendData[10] = (byte) (uSetL); //

        int uCrc = nettyClient.CRC_GetModbus16(sendData, 11);

        //crc16校验低位
        sendData[11] = (byte) (uCrc);
        //crc16校验高位
        sendData[12] = (byte) (uCrc >> 8);
        try {
            // 如果传了指定ip和端口则重置netty链接
            if (StringUtils.hasText(doorDTO.getIp()) && doorDTO.getDevPort() != null) {
                nettyClient.start(doorDTO.getIp(), doorDTO.getDevPort(), sendData);
            }
            nettyClient.send(doorDTO.getIp(), doorDTO.getDevPort(), sendData);
        } catch (Exception e) {
            return false;
        }
        return true;
    }
}

权限系统说明+代码

2023-02-03T08:55:00.000Z

系统权限

说明

功能权限（就是常用的RBAC那一套，登录->控制到按钮级别的权限系统）
数据权限 (根据不用用户，如一个园区分为多家企业，每家企业看到的数据内容不同，园区内不同领导分管不同的多家企业)

功能权限

源码地址

权限框架

spring security

自定义security策略，初步的权限校验，拦截所有的请求，swagger页面和接口无法访问

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                // 跨域检测
                .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
                // 对任何请求都进行权限验证
                .anyRequest().authenticated()
                ;
    }
}

指定页面放开

以swagger和阿里druid连接池监控工具为例，添加以下内容后，swagger内容将正常显示

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // @formatter:off
        http
                .authorizeRequests()
                // 跨域检测
                .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
                // 放行的url
                .antMatchers("/v3/api-docs/**", "/webjars/**", "/druid/**", "/configuration/ui", "/swagger-resources/**", "/css/**", "/js/**", "/plugins/**", "/favicon.ico", "/doc.html", "/static/**").permitAll()
                // 对任何请求都进行权限验证
                .anyRequest().authenticated()
        ;
        // @formatter:on
    }
}

将写死的需要放开的url添加至yml中

# 配置的url
security:
  ignore-urls:
    - /v3/api-docs/**
    - /doc.html
    - /webjars/**
    - /druid/**
    - /static/**
    - /configuration/ui
    - /swagger-resources/**

// 获取配置url内容
@Slf4j
@Configuration
@RequiredArgsConstructor
@ConditionalOnExpression("!'${security.ignore-urls}'.isEmpty()")
@ConfigurationProperties(prefix = "security")
public class PermitAllUrlProperties implements InitializingBean {

    private static final Pattern PATTERN = Pattern.compile("\\{(.*?)\\}");

    private final WebApplicationContext applicationContext;

    @Getter
    @Setter
    private List ignoreUrls = new ArrayList<>();

    @Override
    public void afterPropertiesSet() throws Exception {
        RequestMappingHandlerMapping mapping = applicationContext.getBean(RequestMappingHandlerMapping.class);
        Map map = mapping.getHandlerMethods();

        map.keySet().forEach(info -> {
            HandlerMethod handlerMethod = map.get(info);
        });
    }
}

// 在开放配置中添加上述配置的url
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    private final PermitAllUrlProperties permitAllUrlProperties;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // @formatter:off
        // 防止iframe内容无法展示
        http.headers().frameOptions().disable();
        ExpressionUrlAuthorizationConfigurer
                .ExpressionInterceptUrlRegistry registry = http
                .authorizeRequests();
        // 跨域检测
        registry.antMatchers(HttpMethod.OPTIONS, "/**").permitAll();
        // 忽略鉴权的请求
        permitAllUrlProperties.getIgnoreUrls().forEach(ignoreUrl -> registry.antMatchers(ignoreUrl).permitAll());
        // 对任何请求都进行权限验证
        registry.anyRequest().authenticated()
                .and().csrf().disable();
        // @formatter:on
    }
}

自定义权限验证提示编码和提示文字

// 枚举异常code
@Getter
@RequiredArgsConstructor
@ApiModel(description = "自定义异常code")
public enum SystemCode implements IResultCode {

    /**
     * 自定义异常code枚举
     */
    FORBIDDEN_401(401, "没有访问权限");

    /**
     * code编码
     */
    private final int code;
    /**
     * 中文信息描述
     */
    private final String msg;
}

// 处理权限验证失败的处理类
public class Http401AuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        ResponseUtil.out(response, R.fail(SystemCode.FORBIDDEN_401));
    }
}

1 2	// 将自定义处理添加至配置中 http.exceptionHandling().authenticationEntryPoint(new Http401AuthenticationEntryPoint());

与数据库联动

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for sys_menu
-- ----------------------------
DROP TABLE IF EXISTS `sys_menu`;
CREATE TABLE `sys_menu`  (
  `menu_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '菜单ID',
  `name` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `permission` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `path` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `parent_id` int(11) NULL DEFAULT NULL COMMENT '父菜单ID',
  `icon` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `sort` int(11) NULL DEFAULT 1 COMMENT '排序值',
  `keep_alive` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '0',
  `type` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '0',
  `create_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP(0) COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0) COMMENT '更新时间',
  `del_flag` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '0',
  PRIMARY KEY (`menu_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 10013 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '菜单权限表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_menu
-- ----------------------------
INSERT INTO `sys_menu` VALUES (1000, '权限管理', NULL, '/user', -1, 'icon-quanxianguanli', 0, '0', '0', '2023-02-01 08:29:53', '2023-02-01 08:29:53', '0');
INSERT INTO `sys_menu` VALUES (1100, '用户管理', NULL, '/admin/user/index', 1000, 'icon-yonghuguanli', 1, '1', '1', '2023-02-01 08:29:53', '2023-02-02 09:38:50', '0');
INSERT INTO `sys_menu` VALUES (1101, '用户新增', 'sys_user_add', NULL, 1100, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:38:54', '0');
INSERT INTO `sys_menu` VALUES (1102, '用户修改', 'sys_user_edit', NULL, 1100, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:38:54', '0');
INSERT INTO `sys_menu` VALUES (1103, '用户删除', 'sys_user_del', NULL, 1100, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:38:54', '0');
INSERT INTO `sys_menu` VALUES (1200, '菜单管理', NULL, '/admin/menu/index', 1000, 'icon-caidanguanli', 2, '0', '1', '2023-02-01 08:29:53', '2023-02-02 09:39:39', '0');
INSERT INTO `sys_menu` VALUES (1201, '菜单新增', 'sys_menu_add', NULL, 1200, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:17', '0');
INSERT INTO `sys_menu` VALUES (1202, '菜单修改', 'sys_menu_edit', NULL, 1200, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:17', '0');
INSERT INTO `sys_menu` VALUES (1203, '菜单删除', 'sys_menu_del', NULL, 1200, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:17', '0');
INSERT INTO `sys_menu` VALUES (1300, '角色管理', NULL, '/admin/role/index', 1000, 'icon-jiaoseguanli', 3, '0', '1', '2023-02-01 08:29:53', '2023-02-02 09:39:38', '0');
INSERT INTO `sys_menu` VALUES (1301, '角色新增', 'sys_role_add', NULL, 1300, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:20', '0');
INSERT INTO `sys_menu` VALUES (1302, '角色修改', 'sys_role_edit', NULL, 1300, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:20', '0');
INSERT INTO `sys_menu` VALUES (1303, '角色删除', 'sys_role_del', NULL, 1300, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:20', '0');
INSERT INTO `sys_menu` VALUES (1304, '分配权限', 'sys_role_perm', NULL, 1300, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:20', '0');
INSERT INTO `sys_menu` VALUES (1400, '部门管理', NULL, '/admin/dept/index', 1000, 'icon-web-icon-', 4, '0', '1', '2023-02-01 08:29:53', '2023-02-02 09:39:36', '0');
INSERT INTO `sys_menu` VALUES (1401, '部门新增', 'sys_dept_add', NULL, 1400, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:22', '0');
INSERT INTO `sys_menu` VALUES (1402, '部门修改', 'sys_dept_edit', NULL, 1400, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:23', '0');
INSERT INTO `sys_menu` VALUES (1403, '部门删除', 'sys_dept_del', NULL, 1400, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:23', '0');
INSERT INTO `sys_menu` VALUES (1500, '租户管理', '', '/admin/tenant/index', 1000, 'icon-erji-zuhushouye', 5, '0', '1', '2023-02-01 08:29:53', '2023-02-02 09:39:34', '0');
INSERT INTO `sys_menu` VALUES (1501, '租户新增', 'admin_systenant_add', NULL, 1500, '1', 0, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:25', '0');
INSERT INTO `sys_menu` VALUES (1502, '租户修改', 'admin_systenant_edit', NULL, 1500, '1', 1, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:25', '0');
INSERT INTO `sys_menu` VALUES (1503, '租户删除', 'admin_systenant_del', NULL, 1500, '1', 2, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:25', '0');
INSERT INTO `sys_menu` VALUES (2000, '系统管理', NULL, '/admin', -1, 'icon-xitongguanli', 1, '0', '1', '2023-02-01 08:29:53', '2023-02-02 09:39:33', '0');
INSERT INTO `sys_menu` VALUES (2100, '日志管理', NULL, '/admin/log/index', 2000, 'icon-rizhiguanli', 5, '0', '1', '2023-02-01 08:29:53', '2023-02-02 09:39:33', '0');
INSERT INTO `sys_menu` VALUES (2101, '日志删除', 'sys_log_del', NULL, 2100, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:27', '0');
INSERT INTO `sys_menu` VALUES (2200, '字典管理', NULL, '/admin/dict/index', 2000, 'icon-navicon-zdgl', 6, '0', '1', '2023-02-01 08:29:53', '2023-02-02 09:39:30', '0');
INSERT INTO `sys_menu` VALUES (2201, '字典删除', 'sys_dict_del', NULL, 2200, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:29', '0');
INSERT INTO `sys_menu` VALUES (2202, '字典新增', 'sys_dict_add', NULL, 2200, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:29', '0');
INSERT INTO `sys_menu` VALUES (2203, '字典修改', 'sys_dict_edit', NULL, 2200, NULL, NULL, '0', '2', '2023-02-01 08:29:53', '2023-02-02 09:39:29', '0');

-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role`  (
  `role_id` int(11) NOT NULL AUTO_INCREMENT,
  `role_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `role_code` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `role_desc` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `ds_type` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '2',
  `ds_scope` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `create_time` datetime(0) NOT NULL DEFAULT CURRENT_TIMESTAMP(0),
  `update_time` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0),
  `del_flag` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '0',
  PRIMARY KEY (`role_id`) USING BTREE,
  INDEX `role_idx1_role_code`(`role_code`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '系统角色表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES (1, '管理员', 'ROLE_ADMIN', '管理员', '0', '2', '2023-02-01 15:45:51', '2023-02-01 14:09:11', '0');

-- ----------------------------
-- Table structure for sys_role_menu
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_menu`;
CREATE TABLE `sys_role_menu`  (
  `role_id` int(11) NOT NULL COMMENT '角色ID',
  `menu_id` int(11) NOT NULL COMMENT '菜单ID',
  PRIMARY KEY (`role_id`, `menu_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '角色菜单表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_role_menu
-- ----------------------------
INSERT INTO `sys_role_menu` VALUES (1, 1000);
INSERT INTO `sys_role_menu` VALUES (1, 1100);
INSERT INTO `sys_role_menu` VALUES (1, 1101);
INSERT INTO `sys_role_menu` VALUES (1, 1102);
INSERT INTO `sys_role_menu` VALUES (1, 1103);
INSERT INTO `sys_role_menu` VALUES (1, 1200);
INSERT INTO `sys_role_menu` VALUES (1, 1201);
INSERT INTO `sys_role_menu` VALUES (1, 1202);
INSERT INTO `sys_role_menu` VALUES (1, 1203);
INSERT INTO `sys_role_menu` VALUES (1, 1300);
INSERT INTO `sys_role_menu` VALUES (1, 1301);
INSERT INTO `sys_role_menu` VALUES (1, 1302);
INSERT INTO `sys_role_menu` VALUES (1, 1303);
INSERT INTO `sys_role_menu` VALUES (1, 1304);
INSERT INTO `sys_role_menu` VALUES (1, 1400);
INSERT INTO `sys_role_menu` VALUES (1, 1401);
INSERT INTO `sys_role_menu` VALUES (1, 1402);
INSERT INTO `sys_role_menu` VALUES (1, 1403);
INSERT INTO `sys_role_menu` VALUES (1, 1500);
INSERT INTO `sys_role_menu` VALUES (1, 1501);
INSERT INTO `sys_role_menu` VALUES (1, 1502);
INSERT INTO `sys_role_menu` VALUES (1, 1503);
INSERT INTO `sys_role_menu` VALUES (1, 2000);
INSERT INTO `sys_role_menu` VALUES (1, 2100);
INSERT INTO `sys_role_menu` VALUES (1, 2101);
INSERT INTO `sys_role_menu` VALUES (1, 2200);
INSERT INTO `sys_role_menu` VALUES (1, 2201);
INSERT INTO `sys_role_menu` VALUES (1, 2202);
INSERT INTO `sys_role_menu` VALUES (1, 2203);

-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user`  (
  `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `username` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `salt` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `phone` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `avatar` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `dept_id` int(11) NULL DEFAULT NULL COMMENT '部门ID',
  `create_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP(0) COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0) COMMENT '修改时间',
  `lock_flag` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '0',
  `del_flag` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '0',
  PRIMARY KEY (`user_id`) USING BTREE,
  INDEX `user_idx1_username`(`username`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES (1, 'admin', '$2a$10$IVzj1Wd.ZQdOIWdb1htQjexU94uoNeuk1crlQ9ExVupPi0Iy1uv.C', '', '13812345678', '/admin/sys-file/2023/01/3003703388943b1e2be6dc2e78781fc3.png', 1, '2023-02-01 07:15:18', '2023-02-01 16:45:23', '0', '0');
INSERT INTO `sys_user` (user_id, username, password, salt, phone, avatar, dept_id, create_time, update_time, lock_flag, del_flag) VALUES (2, 'test', '$2a$10$IVzj1Wd.ZQdOIWdb1htQjexU94uoNeuk1crlQ9ExVupPi0Iy1uv.C', null, '13812348765', 'sdsdfwew', 1, '2023-03-01 09:35:31', '2023-03-01 09:35:34', '0', '0');

-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role`  (
  `user_id` int(11) NOT NULL COMMENT '用户ID',
  `role_id` int(11) NOT NULL COMMENT '角色ID',
  PRIMARY KEY (`user_id`, `role_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户角色表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_user_role
-- ----------------------------
INSERT INTO `sys_user_role` VALUES (1, 1);
INSERT INTO `sys_user_role` (user_id, role_id) VALUES (2, 1);

SET FOREIGN_KEY_CHECKS = 1;

token相关


<dependency>
    <groupId>io.jsonwebtokengroupId>
    <artifactId>jjwtartifactId>
    <version>0.9.1version>
dependency>

其他若干工具类等直接见源代码即可

用户登出

// 登出
registry.and().logout().logoutUrl("/token/logout").addLogoutHandler(new SecurityLogoutHandler())
    .deleteCookies("JSESSIONID")
    .logoutSuccessHandler(logoutSuccessHandler());

@Bean
public LogoutSuccessHandler logoutSuccessHandler() {
    return new PasswordLogoutSuccessHandler();
}

添加自定义类SecurityLogoutHandler继承LogoutHandler处理登出时的逻辑，如删除redis中的token缓存记录等。

添加自定义类PasswordLogoutSuccessHandler实现LogoutSuccessHandler处理登出成功后的逻辑，比如跳转指定页面、记录日志、发送邮件通知等

用户登录

自定义用户信息类继承org.springframework.security.core.userdetails.User

public class SysUser extends User {

    /**
     * 用户ID
     */
    @Getter
    private final Long id;
    /**
     * 手机号
     */
    @Getter
    private final String phone;

    /**
     * 头像
     */
    @Getter
    private final String avatar;

    /**
     * 是否为网格员片区总管(0:不是,1:是)
     */
    @Getter
    @Setter
    private Integer isGridHeadUser;

    private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;

    public SysUser(Long id, String phone, String avatar, String username, String password, boolean enabled, boolean accountNonExpired, boolean credentialsNonExpired, boolean accountNonLocked, Collection authorities) {
        super(username, password, enabled, accountNonExpired, credentialsNonExpired, accountNonLocked, authorities);
        this.id = id;
        this.phone = phone;
        this.avatar = avatar;
    }
}

查询权限集合、用户信息、角色列表等信息构建SysUser

@Slf4j
@Service
@RequiredArgsConstructor
public class CustomUserServiceImpl implements UserDetailsService {

    private final SysUserService sysUserService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        UserInfo userInfo = sysUserService.findUserInfoByUserName(username);
        if (userInfo == null) {
            throw new UsernameNotFoundException("指定用户不存在!");
        }
        // 权限标识的集合
        Set dbAuthsSet = new HashSet<>(Arrays.asList(userInfo.getPermissions()));
        Collectionextends GrantedAuthority> authorities
                = AuthorityUtils.createAuthorityList(dbAuthsSet.toArray(new String[0]));
        SysUserEntity user = userInfo.getSysUser();
        // 判断用户是否为正常使用的状态
        boolean enabled = StrUtil.equals(user.getLockFlag(), SecurityConstant.STATUS_NORMAL);
        // @formatter:off
        return new SysUser(
                // 用户id
                user.getUserId(),
                // 用户手机号
                user.getPhone(),
                // 用户头像
                user.getAvatar(),
                // 用户名
                user.getUsername(),
                // 密码
                user.getPassword(),
                // 用户账号是否为正常使用的状态
                enabled,
                true,
                true,
                // 判断用户是否为锁定状态
                !SecurityConstant.STATUS_LOCK.equals(user.getLockFlag()),
                // 权限列表
                authorities
        );
        // @formatter:on
    }
}

自定义登录后返回的字段和内容，自定义一个类CustomJwtToken

public class CustomJwtToken implements Serializable {

    private static final long serialVersionUID = 2149134569530465633L;

    @JsonIgnore
    private String value;

    /**
     * token
     */
    private String token;

    private String tokenType = BEARER_TYPE.toLowerCase();

    /**
     * 权限集合
     */
    private Set permissions;

    public CustomJwtToken(String value) {
        this.value = value;
    }

    @SuppressWarnings("unused")
    private CustomJwtToken() {
        this((String) null);
    }

    public void setValue(String value) {
        this.value = value;
    }

    /**
     * The token value.
     *
     * @return The token value.
     */
    public String getValue() {
        return value;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public String getToken() {
        return token;
    }

    @Override
    public boolean equals(Object obj) {
        return obj != null && toString().equals(obj.toString());
    }

    @Override
    public int hashCode() {
        return toString().hashCode();
    }

    @Override
    public String toString() {
        return String.valueOf(getValue());
    }

    public String getTokenType() {
        return tokenType;
    }

    public void setTokenType(String tokenType) {
        this.tokenType = tokenType;
    }

    public Set getPermissions() {
        return permissions;
    }

    public void setPermissions(Collection authorities) {
        this.permissions = authorities.stream().map(GrantedAuthority::getAuthority).collect(Collectors.toSet());
    }
}

自定义一个身份认证器，并在其中自定义整个登录认证逻辑

@Slf4j
public class CustomDaoAuthenticationProvider extends DaoAuthenticationProvider {

    /**
     * The plaintext password used to perform PasswordEncoder#matches(CharSequence,
     * String)} on when the user is not found to avoid SEC-2056.
     */
    private static final String USER_NOT_FOUND_PASSWORD = "userNotFoundPassword";

    private PasswordEncoder passwordEncoder;

    /**
     * The password used to perform {@link PasswordEncoder#matches(CharSequence, String)}
     * on when the user is not found to avoid SEC-2056. This is necessary, because some
     * {@link PasswordEncoder} implementations will short circuit if the password is not
     * in a valid format.
     */
    private volatile String userNotFoundEncodedPassword;

    private UserDetailsService userDetailsService;

    private UserDetailsPasswordService userDetailsPasswordService;

    /**
     * user 属性校验
     */
    @Setter
    private UserDetailsChecker preAuthenticationChecks = new AccountStatusUserDetailsChecker();

    public CustomDaoAuthenticationProvider() {
    }

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        // 可以在此处覆写整个登录认证逻辑
        if (authentication.getCredentials() == null) {
            log.debug("Failed to authenticate since no credentials provided");
            throw new BadCredentialsException("Bad credentials");
        }

        // 手机号
        String userName = authentication.getName();
        UserDetails userDetails = this.userDetailsService.loadUserByUsername(userName);

        // 校验账号是否禁用
        preAuthenticationChecks.check(userDetails);

        // 账号密码校验
        additionalAuthenticationChecks(userDetails,
                (UsernamePasswordAuthenticationToken) authentication);

        // 提供用户名、密码、权限列表供SecurityLoginFilter使用
        return new UsernamePasswordAuthenticationToken(userName, userDetails.getPassword(), userDetails.getAuthorities());
    }

    @Override
    @SuppressWarnings("deprecation")
    protected void additionalAuthenticationChecks(UserDetails userDetails,
                                                  UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
        // 可以在此覆写整个密码校验逻辑
        if (authentication.getCredentials() == null) {
            this.logger.debug("Failed to authenticate since no credentials provided");
            throw new BadCredentialsException(this.messages
                    .getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
        }
        String presentedPassword = authentication.getCredentials().toString();
        if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
            this.logger.debug("Failed to authenticate since password does not match stored value");
            throw new BadCredentialsException(this.messages
                    .getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
        }
    }

    @Override
    protected Authentication createSuccessAuthentication(Object principal, Authentication authentication,
                                                         UserDetails user) {
        boolean upgradeEncoding = this.userDetailsPasswordService != null
                && this.passwordEncoder.upgradeEncoding(user.getPassword());
        if (upgradeEncoding) {
            String presentedPassword = authentication.getCredentials().toString();
            String newPassword = this.passwordEncoder.encode(presentedPassword);
            user = this.userDetailsPasswordService.updatePassword(user, newPassword);
        }
        return super.createSuccessAuthentication(principal, authentication, user);
    }

    /**
     * Sets the PasswordEncoder instance to be used to encode and validate passwords. If
     * not set, the password will be compared using
     * {@link PasswordEncoderFactories#createDelegatingPasswordEncoder()}
     *
     * @param passwordEncoder must be an instance of one of the {@code PasswordEncoder}
     *                        types.
     */
    public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
        Assert.notNull(passwordEncoder, "passwordEncoder cannot be null");
        this.passwordEncoder = passwordEncoder;
        this.userNotFoundEncodedPassword = null;
    }

    protected PasswordEncoder getPasswordEncoder() {
        return this.passwordEncoder;
    }

    public void setUserDetailsService(UserDetailsService userDetailsService) {
        this.userDetailsService = userDetailsService;
    }

    protected UserDetailsService getUserDetailsService() {
        return this.userDetailsService;
    }

    public void setUserDetailsPasswordService(UserDetailsPasswordService userDetailsPasswordService) {
        this.userDetailsPasswordService = userDetailsPasswordService;
    }
}

将自定义的身份认证逻辑设置进WebSecurityConfig策略中

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    // 自定义身份认证器
    CustomDaoAuthenticationProvider daoAuthenticationProvider = new CustomDaoAuthenticationProvider();
    // 指定加密方式
    daoAuthenticationProvider.setPasswordEncoder(passwordEncoder());
    // 用户账号密码、权限等信息获取
    daoAuthenticationProvider.setUserDetailsService(customUserService);
    auth.authenticationProvider(daoAuthenticationProvider);
}

添加登陆过滤器，检查输入的用户名和密码，并根据认证结果决定是否将这一结果传递给下一个过滤器。验证成功则颁发token

public class SecurityLoginFilter extends UsernamePasswordAuthenticationFilter {

    private final AuthenticationManager authenticationManager;

    public SecurityLoginFilter(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;
    }

    /**
     * 尝试身份认证(接收并解析用户凭证)
     *
     * @param request
     * @param response
     * @return
     * @throws AuthenticationException
     */
    @SneakyThrows
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        LoginDTO user = new ObjectMapper().readValue(request.getInputStream(), LoginDTO.class);
        return authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        user.getUsername(),
                        user.getPassword(),
                        new ArrayList<>()
                ));
    }

    /**
     * 认证成功(用户成功登录后，这个方法会被调用，生成token)
     *
     * @param request
     * @param response
     * @param chain
     * @param auth
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest request,
                                            HttpServletResponse response,
                                            FilterChain chain,
                                            Authentication auth) throws IOException, ServletException {
        // 存储登录认证信息到上下文
        SecurityContextHolder.getContext().setAuthentication(auth);
        // 触发成功登录事件监听器
        if (this.eventPublisher != null) {
            eventPublisher.publishEvent(new InteractiveAuthenticationSuccessEvent(auth, this.getClass()));
        }
        // 生成并返回token给客户端，后续访问携带此token
        CustomJwtToken token = new CustomJwtToken(UUID.randomUUID().toString());
        token.setToken(TokenUtil.generateToken(auth));
        token.setPermissions(auth.getAuthorities());
        // TODO 储存redis
        // 返回Token 相关信息
        ResponseUtil.out(response, R.ok(token));
        // 记录日志
    }

    /**
     * 认证失败调用
     *
     * @param request
     * @param response
     * @param failed
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response,
                                              AuthenticationException failed) throws IOException, ServletException {
        // 使用的是自定义code:401003 所以在response中不能设置该自定义的code
        ResponseUtil.write(response, SystemCode.USERNAME_OR_PASSWORD_ERROR);
        // 记录日志
    }
}

添加过滤器验证需要验证用户请求时所带的token是否正确

package cn.allbs.allbsjwt.config.filter;

import cn.allbs.allbsjwt.config.utils.TokenUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.util.StringUtils;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
public class TokenAuthenticationFilter extends BasicAuthenticationFilter {

    private final UserDetailsService userDetailsService;

    public TokenAuthenticationFilter(AuthenticationManager authenticationManager, UserDetailsService userDetailsService) {
        super(authenticationManager);
        this.userDetailsService = userDetailsService;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        String token = TokenUtil.getToken(request);
        // 如果token存在 则验证token是否正确和过期 TODO 去redis中判断token是否存在
        if (!TokenUtil.validateToken(token)) {
            // token 验证不通过
            chain.doFilter(request, response);
            return;
        }
        Authentication authentication = getAuthentication(token);
        SecurityContextHolder.getContext().setAuthentication(authentication);
        chain.doFilter(request, response);
    }

    private Authentication getAuthentication(String token) {
        String username = TokenUtil.getUsernameFromToken(token);
        if (StringUtils.hasText(username)) {
            // 查询当前用户权限集合,因为并没有将权限列表放在token中所以无法通过token解析出来，去数据库或者redis中获取,当然放在token中也是可以的
            UserDetails userInfo = this.userDetailsService.loadUserByUsername(username);
            return new UsernamePasswordAuthenticationToken(username, token, userInfo.getAuthorities());
        }
        return null;
    }
}

在spring security配置文件中添加该过滤器

@Override
protected void configure(HttpSecurity http) throws Exception {
    // @formatter:off
    // 防止iframe内容无法展示
    http.headers().frameOptions().disable();
    // 需要权限验证的提示code和文字说明自定义
    http.exceptionHandling().authenticationEntryPoint(new Http401AuthenticationEntryPoint());
    ExpressionUrlAuthorizationConfigurer
            .ExpressionInterceptUrlRegistry registry = http
            .authorizeRequests();
    // 跨域检测
    registry.antMatchers(HttpMethod.OPTIONS, "/**").permitAll();
    // 忽略鉴权的请求
    permitAllUrlProperties.getIgnoreUrls().forEach(ignoreUrl -> registry.antMatchers(ignoreUrl).permitAll());
    // 登出
    registry.and().logout().logoutUrl("/token/logout").addLogoutHandler(new SecurityLogoutHandler())
            .deleteCookies("JSESSIONID")
            .logoutSuccessHandler(logoutSuccessHandler());
    // 登录
    registry.and().formLogin().loginPage("/login").permitAll();
    registry.and()
            // 登录并颁发token
            .addFilter(new SecurityLoginFilter(authenticationManager()));
    // 对任何请求都进行权限验证
    registry.anyRequest().authenticated()
            .and().csrf().disable();
    registry.and()
            // 移除session
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    // 验证续签token
    registry.and().addFilterBefore(new TokenAuthenticationFilter(authenticationManager(), customUserService), UsernamePasswordAuthenticationFilter.class);
    // @formatter:on
}

至此，从数据库中登录，获取用户名、密码、菜单、权限，登出功能已完成

资源访问权限

新增PermissionService用于接口指定访问权限

在WebSecurityConfig中添加注解@EnableGlobalMethodSecurity(prePostEnabled=true)

如果用户的权限列表中不包含该权限则不允许访问。一般用于按钮级别权限的控制。

package com.lyc.admin.oauth.service;

import cn.hutool.core.util.ArrayUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.PatternMatchUtils;
import org.springframework.util.StringUtils;

import java.util.Collection;

@Slf4j
@Component("pms")
public class PermissionService {
    /**
     * 判断接口是否有任意xxx，xxx权限
     *
     * @param permissions 权限
     * @return {boolean}
     */
    public boolean hasPermission(String... permissions) {
        if (ArrayUtil.isEmpty(permissions)) {
            return false;
        }
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null) {
            return false;
        }
        Collectionextends GrantedAuthority> authorities = authentication.getAuthorities();
        return authorities.stream()
                .map(GrantedAuthority::getAuthority)
                .filter(StringUtils::hasText)
                .anyMatch(x -> PatternMatchUtils.simpleMatch(permissions, x));
    }
}

测试，添加两个接口，一个接口含有permission中的字符串，一个没有。@PreAuthorize 使用时如果没有权限将不会进入方法。

postman调用结果

统一403返回格式

// enum
FORBIDDEN_403(403, "缺少资源访问权限!"),

// 403自定义处理
public class Http403AccessDeniedEntryPoint implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        ResponseUtil.out(response, R.fail(SystemCode.FORBIDDEN_403));
    }
}

// 加入配置
HttpSecurity.exceptionHandling().accessDeniedHandler(new Http403AccessDeniedEntryPoint());

权限控制没有权限,方法依然执行但是不会返回

使用场景，比如只允许用户查询自己的用户信息。

对返回结果进行过滤

对请求参数进行过滤

oauth2.0

数据权限

实现方式

以下使用的方式是拦截sql后自定义组装来实现数据过滤

代码实现1

定义一个注解`DataScope`用于判断哪些类、方法需要进行数据过滤。当然你也可以稍微修改下，默认对数据进行过滤，指定类、方法不过滤

package cn.allbs.allbsjwt.config.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;

@Target({METHOD, TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataScope {

    /**
     * 当进行过滤时主表中代表企业id的字段
     */
    String unitField() default "ent_id";

    /**
     * 是否进行数据过滤
     */
    boolean filterData() default true;

    /**
     * 忽略的表名
     *
     * @return 不进行数据过滤的表名的集合
     */
    String[] ignoreTables() default {"sys_file"};
}

定义一个实体类用户临时储存sql过滤中需要使用的参数信息

@Data
@EqualsAndHashCode(callSuper = true)
@RequiredArgsConstructor
public class DataScopeParam extends HashMap {

    /**
     * 企业筛选字段名称（比如某个表中并未使用其他表通用的字段ent_id进行区分企业）
     */
    private String unitField;

    /**
     * 企业数据范围
     */
    private Set entIdList;

    /**
     * 是否进行拦截
     */
    private boolean filterField;

    /**
     * 忽略不过滤的表名
     */
    private List ignoreTables;
}

权限解析器

@Slf4j
public class DataScopeAnnotationClassResolver {

    /**
     * 缓存方法对应的权限拦截
     */
    private final Map dsCache = new ConcurrentHashMap<>();

    public DataScopeAnnotationClassResolver() {
    }

    /**
     * 从缓存获取数据
     *
     * @param method       方法
     * @param targetObject 目标对象
     * @return ds
     */
    public DataScopeParam findKey(Method method, Object targetObject) {
        if (method.getDeclaringClass() == Object.class) {
            return null;
        }
        Object cacheKey = new MethodClassKey(method, targetObject.getClass());
        DataScopeParam dsp = this.dsCache.get(cacheKey);
        if (dsp == null) {
            dsp = computeDatasource(method, targetObject);
            this.dsCache.put(cacheKey, dsp);
        }
        return dsp;
    }

    /**
     * 查找注解的顺序
     * 1. 当前方法
     * 2. 桥接方法
     * 3. 当前类开始一直找到Object
     *
     * @param method       方法
     * @param targetObject 目标对象
     * @return ds
     */
    private DataScopeParam computeDatasource(Method method, Object targetObject) {
        if (!Modifier.isPublic(method.getModifiers())) {
            return null;
        }
        //1. 从当前方法接口中获取
        DataScopeParam dsAttr = findDataSourceAttribute(method);
        if (dsAttr != null) {
            return dsAttr;
        }
        Class targetClass = targetObject.getClass();
        Class userClass = ClassUtils.getUserClass(targetClass);
        // JDK代理时,  获取实现类的方法声明.  method: 接口的方法, specificMethod: 实现类方法
        Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);

        specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
        //2. 从桥接方法查找
        dsAttr = findDataSourceAttribute(specificMethod);
        if (dsAttr != null) {
            return dsAttr;
        }
        // 从当前方法声明的类查找
        dsAttr = findDataSourceAttribute(userClass);
        if (dsAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return dsAttr;
        }
        //since 3.4.1 从接口查找，只取第一个找到的
        for (Class interfaceClazz : ClassUtils.getAllInterfacesForClassAsSet(userClass)) {
            dsAttr = findDataSourceAttribute(interfaceClazz);
            if (dsAttr != null) {
                return dsAttr;
            }
        }
        // 如果存在桥接方法
        if (specificMethod != method) {
            // 从桥接方法查找
            dsAttr = findDataSourceAttribute(method);
            if (dsAttr != null) {
                return dsAttr;
            }
            // 从桥接方法声明的类查找
            dsAttr = findDataSourceAttribute(method.getDeclaringClass());
            if (dsAttr != null && ClassUtils.isUserLevelMethod(method)) {
                return dsAttr;
            }
        }
        return getDefaultDataSourceAttr(targetObject);
    }

    /**
     * 默认的获取
     *
     * @param targetObject 目标对象
     * @return DataScopeParam
     */
    private DataScopeParam getDefaultDataSourceAttr(Object targetObject) {
        Class targetClass = targetObject.getClass();
        // 如果不是代理类, 从当前类开始, 不断的找父类的声明
        if (!Proxy.isProxyClass(targetClass)) {
            Class currentClass = targetClass;
            while (currentClass != Object.class) {
                DataScopeParam datasourceAttr = findDataSourceAttribute(currentClass);
                if (datasourceAttr != null) {
                    return datasourceAttr;
                }
                currentClass = currentClass.getSuperclass();
            }
        }
        return null;
    }

    /**
     * 通过 AnnotatedElement 查找标记的注解, 映射为  DatasourceHolder
     *
     * @param ae AnnotatedElement
     * @return 数据源映射持有者
     */
    private DataScopeParam findDataSourceAttribute(AnnotatedElement ae) {
        AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, DataScope.class);
        DataScopeParam dsp = null;
        if (attributes != null) {
            dsp = new DataScopeParam(attributes.getString("unitField"), new HashSet<>(), attributes.getBoolean("filterData"), Convert.toList(String.class, attributes.get("ignoreTables")));
        }
        return dsp;
    }
}

处理自定义切面

public class DataScopeAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {

    private final Advice advice;

    private final Pointcut pointcut;

    private final Classextends Annotation> annotation;

    public DataScopeAnnotationAdvisor(@NonNull MethodInterceptor advice,
                                      @NonNull Class annotation) {
        this.advice = advice;
        this.annotation = annotation;
        this.pointcut = buildPointcut();
    }

    @Override
    public Pointcut getPointcut() {
        return this.pointcut;
    }

    @Override
    public Advice getAdvice() {
        return this.advice;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        if (this.advice instanceof BeanFactoryAware) {
            ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
        }
    }

    private Pointcut buildPointcut() {
        Pointcut cpc = new AnnotationMatchingPointcut(annotation, true);
        Pointcut mpc = new AnnotationMethodPoint(annotation);
        return new ComposablePointcut(cpc).union(mpc);
    }

    /**
     * In order to be compatible with the spring lower than 5.0
     */
    private static class AnnotationMethodPoint implements Pointcut {

        private final Classextends Annotation> annotationType;

        public AnnotationMethodPoint(Class annotationType) {
            Assert.notNull(annotationType, "Annotation type must not be null");
            this.annotationType = annotationType;
        }

        @Override
        public ClassFilter getClassFilter() {
            return ClassFilter.TRUE;
        }

        @Override
        public MethodMatcher getMethodMatcher() {
            return new AnnotationMethodMatcher(annotationType);
        }

        private static class AnnotationMethodMatcher extends StaticMethodMatcher {
            private final Classextends Annotation> annotationType;

            public AnnotationMethodMatcher(Class annotationType) {
                this.annotationType = annotationType;
            }

            @Override
            public boolean matches(Method method, Class targetClass) {
                if (matchesMethod(method)) {
                    return true;
                }
                // Proxy classes never have annotations on their redeclared methods.
                if (Proxy.isProxyClass(targetClass)) {
                    return false;
                }
                // The method may be on an interface, so let's check on the target class as well.
                Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
                return (specificMethod != method && matchesMethod(specificMethod));
            }

            private boolean matchesMethod(Method method) {
                return AnnotatedElementUtils.hasAnnotation(method, this.annotationType);
            }
        }
    }
}

添加`DataScopeParamContentHolder`用户储存需要过滤数据的配置信息

import com.alibaba.ttl.TransmittableThreadLocal;

public final class DataScopeParamContentHolder {

    private DataScopeParamContentHolder() {
    }

    private static final ThreadLocal THREAD_PMS_HOLDER = new TransmittableThreadLocal<>();

    /**
     * 设置当前header中的权限
     *
     * @param dataScopeParam 需要过滤的权限
     */
    public static void set(DataScopeParam dataScopeParam) {
        THREAD_PMS_HOLDER.set(dataScopeParam);
    }

    /**
     * 获取header中的权限
     *
     * @return 权限
     */
    public static DataScopeParam get() {
        return THREAD_PMS_HOLDER.get();
    }

    public static void clear() {
        THREAD_PMS_HOLDER.remove();
    }
}

添加拦截器`DataScopeAnnotationIntercept`用于拦截方法级别的注解，处理添加了上方自定义注解的方法,缓存自定义注解中的配置

public class DataScopeAnnotationIntercept implements MethodInterceptor {

    private final DataScopeAnnotationClassResolver dataScopeAnnotationClassResolver;

    public DataScopeAnnotationIntercept() {
        dataScopeAnnotationClassResolver = new DataScopeAnnotationClassResolver();
    }

    @Nullable
    @Override
    public Object invoke(@NotNull MethodInvocation methodInvocation) throws Throwable {
        DataScopeParam paramKey = dataScopeAnnotationClassResolver.findKey(methodInvocation.getMethod(), methodInvocation.getThis());
        DataScopeParamContentHolder.set(paramKey);
        try {
            return methodInvocation.proceed();
        } finally {
            DataScopeParamContentHolder.clear();
        }
    }
}

添加配置将上述内容注册进去

@Configuration
public class DataScopeInitConfig {

    @Bean
    public Advisor generateAllDataScopeAdvisor() {
        DataScopeAnnotationIntercept intercept = new DataScopeAnnotationIntercept();
        DataScopeAnnotationAdvisor advisor = new DataScopeAnnotationAdvisor(intercept, DataScope.class);
        advisor.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return advisor;
    }
}

最后根据配置内容信息对应的处理sql，这个类是关键，前面所有内容都是为他服务，如果只是想简单点写死代码直接使用该类就可以了

package cn.allbs.allbsjwt.config.datascope;

import cn.allbs.allbsjwt.config.exception.UnauthorizedException;
import cn.allbs.allbsjwt.config.utils.SecurityUtils;
import cn.allbs.allbsjwt.config.vo.SysUser;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.toolkit.PluginUtils;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Alias;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SelectBody;
import net.sf.jsqlparser.statement.select.SetOperationList;
import net.sf.jsqlparser.statement.update.Update;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.io.StringReader;
import java.sql.Connection;
import java.util.List;
import java.util.Properties;
import java.util.Set;

@Aspect
@Slf4j
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
@Component
public class UnitDataPermissionInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 在有权限的情况下查询用户所关联的企业列表
        SysUser sysUser = SecurityUtils.getUser();
        // 如果非权限用户则不往下执行
        if (sysUser == null) {
            return invocation.proceed();
        }

        DataScopeParam dataScopeParam = DataScopeParamContentHolder.get();

        if (dataScopeParam != null) {
            dataScopeParam.setEntIdList(sysUser.getEntIdList());
        }

        // 获取header中的待过滤的企业列表
//        Set entIdList = CurrentEntIdSearchContextHolder.getEntIdList();
//        if (entIdList != null) {
//            if (dataScopeParam == null) {
//                dataScopeParam = new DataScopeParam("ent_id", entIdList, true, CollUtil.newArrayList("sys_file"));
//            } else {
//                // 查询交集
//                Set permissionEntList = dataScopeParam.getEntIdList();
//                dataScopeParam.setFilterField(true);
//                dataScopeParam.setEntIdList(entIdList.stream().filter(permissionEntList::contains).collect(Collectors.toSet()));
//            }
//        }

        // 没有添加注解则不往下执行
        if (dataScopeParam == null) {
            return invocation.proceed();
        }

        // 注解配置不过滤数据则不往下执行
        if (!dataScopeParam.isFilterField()) {
            return invocation.proceed();
        }

        StatementHandler statementHandler = PluginUtils.realTarget(invocation.getTarget());
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        // 先判断是不是SELECT操作 不是直接过滤
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        if (SqlCommandType.FLUSH.equals(mappedStatement.getSqlCommandType()) || SqlCommandType.UNKNOWN.equals(mappedStatement.getSqlCommandType())) {
            return invocation.proceed();
        }

        BoundSql boundSql = (BoundSql) metaObject.getValue("delegate.boundSql");
        // 执行的SQL语句
        String originalSql = boundSql.getSql();
        // SQL语句的参数
        Object parameterObject = boundSql.getParameterObject();
        // 拦截插入语句
        if (SqlCommandType.INSERT.equals(mappedStatement.getSqlCommandType())) {
            // 当为insert时将判断是否具备权限
            if (parameterObject != null) {
                Long entId = Convert.toLong(ReflectUtil.getFieldValue(parameterObject, StrUtil.toCamelCase(dataScopeParam.getUnitField())));
                // 判断entId是否在权限范围内
                if (entId != null && !dataScopeParam.getEntIdList().contains(entId)) {
                    throw new UnauthorizedException("entId不在权限范围内");
                }
            }
            return invocation.proceed();
        }
        // 拦截更新语句，业务包含逻辑删除所以此处用的update
        if (SqlCommandType.UPDATE.equals(mappedStatement.getSqlCommandType())) {
            // 修改updateSql
            String updateSql = handleUpdateSql(originalSql, dataScopeParam.getEntIdList(), dataScopeParam.getUnitField(), dataScopeParam.getIgnoreTables());
            log.warn("数据权限处理过后UPDATE的SQL: {}", updateSql);
            metaObject.setValue("delegate.boundSql.sql", updateSql);
            return invocation.proceed();
        }
        // 需要过滤的数据
        String finalSql = this.handleSql(originalSql, dataScopeParam.getEntIdList(), dataScopeParam.getUnitField(), dataScopeParam.getIgnoreTables());
        log.warn("数据权限处理过后SELECT的SQL: {}", finalSql);

        // 装载改写后的sql
        metaObject.setValue("delegate.boundSql.sql", finalSql);
        return invocation.proceed();
    }


    /**
     * 修改select语句sql
     *
     * @param originalSql 原始sql
     * @param entIdList   需要过滤的企业列表
     * @param fieldName   当前主表中字段名称
     * @return 修改后的语句
     * @throws JSQLParserException sql修改异常
     */
    private String handleSql(String originalSql, Set entIdList, String fieldName, List ignores) throws JSQLParserException {
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        Select select = (Select) parserManager.parse(new StringReader(originalSql));
        SelectBody selectBody = select.getSelectBody();
        if (selectBody instanceof PlainSelect) {
            this.setWhere((PlainSelect) selectBody, entIdList, fieldName, ignores);
        } else if (selectBody instanceof SetOperationList) {
            SetOperationList setOperationList = (SetOperationList) selectBody;
            List selectBodyList = setOperationList.getSelects();
            selectBodyList.forEach(s -> this.setWhere((PlainSelect) s, entIdList, fieldName, ignores));
        }
        return select.toString();
    }

    /**
     * 修改update语句
     *
     * @param originalSql 元素sql
     * @param entIdList   允许查询的企业列表
     * @param fieldName   表中待过滤查询的列名
     * @param ignores     忽略的表名
     * @return
     * @throws JSQLParserException
     */
    private String handleUpdateSql(String originalSql, Set entIdList, String fieldName, List ignores) throws JSQLParserException {
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        Update update = (Update) parserManager.parse(new StringReader(originalSql));
        if (ignores.contains(update.getTable().getName())) {
            // 当前表名的处于不过滤列表则不进行二次封装处理
            return originalSql;
        }
        String dataPermissionSql;
        if (entIdList.size() == 1) {
            EqualsTo selfEqualsTo = new EqualsTo();
            selfEqualsTo.setLeftExpression(new Column(fieldName));
            selfEqualsTo.setRightExpression(new LongValue(entIdList.stream().findFirst().orElse(0L)));
            dataPermissionSql = selfEqualsTo.toString();
        } else {
            dataPermissionSql = fieldName + " in ( " + CollUtil.join(entIdList, StringPool.COMMA) + " )";
        }
        update.setWhere(new AndExpression(update.getWhere(), CCJSqlParserUtil.parseCondExpression(dataPermissionSql)));
        return update.toString();
    }

    /**
     * 设置 where 条件  --  使用CCJSqlParser将原SQL进行解析并改写
     *
     * @param plainSelect 查询对象
     */
    @SneakyThrows(Exception.class)
    protected void setWhere(PlainSelect plainSelect, Set entIdList, String fieldName, List ignores) {
        Table fromItem = (Table) plainSelect.getFromItem();
        // 有别名用别名，无别名用表名，防止字段冲突报错
        Alias fromItemAlias = fromItem.getAlias();
        if (ignores.contains(fromItem.getName())) {
            // 当前表名的处于不过滤列表则不进行二次封装处理
            return;
        }
        String mainTableName = fromItemAlias == null ? fromItem.getName() : fromItemAlias.getName();
        // 构建子查询 -- 数据权限过滤SQL
        String dataPermissionSql;
        if (entIdList.size() == 1) {
            EqualsTo selfEqualsTo = new EqualsTo();
            selfEqualsTo.setLeftExpression(new Column(mainTableName + "." + fieldName));
            selfEqualsTo.setRightExpression(new LongValue(entIdList.stream().findFirst().orElse(0L)));
            dataPermissionSql = selfEqualsTo.toString();
        } else if (entIdList.size() < 1) {
            dataPermissionSql = mainTableName + "." + fieldName + " in ( " + StringPool.NULL + " )";
        } else {
            dataPermissionSql = mainTableName + "." + fieldName + " in ( " + CollUtil.join(entIdList, StringPool.COMMA) + " )";
        }

        if (plainSelect.getWhere() == null) {
            plainSelect.setWhere(CCJSqlParserUtil.parseCondExpression(dataPermissionSql));
        } else {
            plainSelect.setWhere(new AndExpression(plainSelect.getWhere(), CCJSqlParserUtil.parseCondExpression(dataPermissionSql)));
        }
    }

    /**
     * 生成拦截对象的代理
     *
     * @param target 目标对象
     * @return 代理对象
     */
    @Override
    public Object plugin(Object target) {
        if (target instanceof StatementHandler) {
            return Plugin.wrap(target, this);
        }
        return target;
    }

    /**
     * mybatis配置的属性
     *
     * @param properties mybatis配置的属性
     */
    @Override
    public void setProperties(Properties properties) {
        log.info(properties.toString());
    }
}

新建几张表并插入数据用于数据测试

企业信息表`cm_enterprise`

create table cm_enterprise
(
    id          bigint                             not null comment '主键'
        primary key,
    name        varchar(255)                       not null comment '企业名称',
    create_time datetime default CURRENT_TIMESTAMP not null,
    update_time datetime                           not null on update CURRENT_TIMESTAMP,
    del_flag    char     default '0'               not null
)
    comment '企业信息表';
INSERT INTO authorization_demo.cm_enterprise (id, name, create_time, update_time, del_flag) VALUES (1, '企业1', '2023-03-01 09:33:48', '2023-03-01 09:33:58', '0');
INSERT INTO authorization_demo.cm_enterprise (id, name, create_time, update_time, del_flag) VALUES (2, '企业2', '2023-03-01 09:33:50', '2023-03-01 09:33:59', '0');
INSERT INTO authorization_demo.cm_enterprise (id, name, create_time, update_time, del_flag) VALUES (3, '企业3', '2023-03-01 09:33:55', '2023-03-01 09:34:00', '0');
INSERT INTO authorization_demo.cm_enterprise (id, name, create_time, update_time, del_flag) VALUES (4, '企业4', '2023-03-01 09:33:56', '2023-03-01 09:34:01', '0');
INSERT INTO authorization_demo.cm_enterprise (id, name, create_time, update_time, del_flag) VALUES (5, '企业5', '2023-03-01 09:33:57', '2023-03-01 09:34:02', '0');

id	name	create_time	update_time
1	企业1	2023-03-01 09:33:48	2023-03-01 09:33:58
2	企业2	2023-03-01 09:33:50	2023-03-01 09:33:59
3	企业3	2023-03-01 09:33:55	2023-03-01 09:34:00
4	企业4	2023-03-01 09:33:56	2023-03-01 09:34:01
5	企业5	2023-03-01 09:33:57	2023-03-01 09:34:02

用户企业关联表`cm_user_enterprise`

-- auto-generated definition
create table cm_user_enterprise
(
    user_id bigint not null comment '用户id',
    ent_id  bigint not null comment '企业id'
)
    comment '用户企业关联表';
INSERT INTO authorization_demo.cm_user_enterprise (user_id, ent_id) VALUES (1, 1);
INSERT INTO authorization_demo.cm_user_enterprise (user_id, ent_id) VALUES (1, 2);
INSERT INTO authorization_demo.cm_user_enterprise (user_id, ent_id) VALUES (1, 3);
INSERT INTO authorization_demo.cm_user_enterprise (user_id, ent_id) VALUES (2, 3);
INSERT INTO authorization_demo.cm_user_enterprise (user_id, ent_id) VALUES (2, 4);
INSERT INTO authorization_demo.cm_user_enterprise (user_id, ent_id) VALUES (2, 5);

user_id	ent_id
1	1
1	2
1	3
2	3
2	4
2	5

假设用户admin具备企业1、2、3的权限。用户test具备企业3、4、5的权限

企业数据测试表`cm_ent_data`

create table cm_ent_data
(
    id          bigint auto_increment comment '主键'
        primary key,
    ent_id      bigint       not null comment '企业id',
    description varchar(200) null comment '说明'
)
    comment '用户数据测试的表';
INSERT INTO authorization_demo.cm_ent_data (id, ent_id, description) VALUES (1, 1, '企业1的测试数据1号');
INSERT INTO authorization_demo.cm_ent_data (id, ent_id, description) VALUES (2, 2, '企业2的测试数据1号');
INSERT INTO authorization_demo.cm_ent_data (id, ent_id, description) VALUES (3, 3, '企业3的测试数据1号');
INSERT INTO authorization_demo.cm_ent_data (id, ent_id, description) VALUES (4, 4, '企业4的测试数据1号');
INSERT INTO authorization_demo.cm_ent_data (id, ent_id, description) VALUES (5, 5, '企业5的测试数据1号');
INSERT INTO authorization_demo.cm_ent_data (id, ent_id, description) VALUES (6, 2, '企业2的测试数据2号');
INSERT INTO authorization_demo.cm_ent_data (id, ent_id, description) VALUES (7, 3, '企业3的测试数据2号');

id	ent_id	description
1	1	企业1的测试数据1号
2	2	企业2的测试数据1号
3	3	企业3的测试数据1号
4	4	企业4的测试数据1号
5	5	企业5的测试数据1号
6	2	企业2的测试数据2号
7	3	企业3的测试数据2号

假设企业2、3分别有2条数据，企业1、4、5分别只有一条数据

这三张表生成对应的controller、service、mapper文件

建议用easycode插件，具体使用方法和模版（生成后的内容需要更新实际情况改改）

📃 关联文档

📄 easy code使用及模版

登录时查询用户关联的企业列表并缓存，当然如果怕影响登录速度，可以在登录后执行一个异步方法进行相关操作

具体添加的代码见对应的git提交即可，总之这一步主要目的就是让权限系统中的用户信息中含有该用户的关联企业列表

启动项目后进行测试

未加`dataScope`注解查询企业数据测试表，结果显示查出全部数据

添加注解测试，用户admin关联企业1、2、3查询结果符合期望

现在有个需求，根据前端需要查询的企业进行数据筛选

增加一个Holder用于储存当前查询ent_id列表

package cn.allbs.allbsjwt.config.datascope;

import com.alibaba.ttl.TransmittableThreadLocal;
import lombok.experimental.UtilityClass;

import java.util.Set;

@UtilityClass
public class CurrentEntIdSearchContextHolder {

    private final ThreadLocal> THREAD_LOCAL_ENT_LIST = new TransmittableThreadLocal<>();

    /**
     * 设置当前header中的企业列表
     *
     * @param entIdList 需要查询的企业列表
     */
    public void setEntIdList(Set entIdList) {
        THREAD_LOCAL_ENT_LIST.set(entIdList);
    }

    /**
     * 获取header中的企业列表
     *
     * @return 企业列表
     */
    public Set getEntIdList() {
        return THREAD_LOCAL_ENT_LIST.get();
    }

    public void clear() {
        THREAD_LOCAL_ENT_LIST.remove();
    }
}

添加过滤器，将前端传输的数据储存起来

package cn.allbs.allbsjwt.config.datascope;

import cn.allbs.allbsjwt.config.constant.CommonConstants;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.StrUtil;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Set;

@Slf4j
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class EntIdContextHolderFilter extends GenericFilterBean {

    @Override
    @SneakyThrows
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        String entIdListStr = request.getHeader(CommonConstants.ENT_ID_LIST);

        if (StrUtil.isNullOrUndefined(entIdListStr)) {
            CurrentEntIdSearchContextHolder.clear();
        } else {
            Set entIdList = Convert.toSet(Long.class, entIdListStr);
            CurrentEntIdSearchContextHolder.setEntIdList(entIdList);
            log.debug("获取header中的企业列表为:{}", entIdList);
        }

        filterChain.doFilter(request, response);
        CurrentEntIdSearchContextHolder.clear();
    }
}

在`UnitDataPermissionInterceptor`中添加代码过滤用户查询的企业列表

// 获取header中的待过滤的企业列表
Set entIdList = CurrentEntIdSearchContextHolder.getEntIdList();
if (entIdList != null) {
    if (dataScopeParam == null) {
        dataScopeParam = new DataScopeParam("ent_id", entIdList, true, CollUtil.newArrayList("sys_file"));
    } else {
        // 查询交集
        Set permissionEntList = dataScopeParam.getEntIdList();
        dataScopeParam.setFilterField(true);
        dataScopeParam.setEntIdList(entIdList.stream().filter(permissionEntList::contains).collect(Collectors.toSet()));
    }
}

进行测试

在添加`dataScope`的情况下只查询到企业符合期望

去掉`datascope`进行测试

没有企业3的数据符合预期

源码

源码地址

实现方式二

📄 实现文档

在指定时间执行js中的方法

2023-01-10T03:39:00.000Z

使用moment.js库

官网下载

//! moment.js

;
(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
        typeof define === 'function' && define.amd ? define(factory) :
            global.moment = factory()
}(this, (function () {
    'use strict';

    var hookCallback;

    function hooks() {
        return hookCallback.apply(null, arguments);
    }

    // This is done to register the method called with moment()
    // without creating circular dependencies.
    function setHookCallback(callback) {
        hookCallback = callback;
    }

    function isArray(input) {
        return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
    }

    function isObject(input) {
        // IE8 will treat undefined and null as object if it wasn't for
        // input != null
        return input != null && Object.prototype.toString.call(input) === '[object Object]';
    }

    function isObjectEmpty(obj) {
        if (Object.getOwnPropertyNames) {
            return (Object.getOwnPropertyNames(obj).length === 0);
        } else {
            var k;
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    return false;
                }
            }
            return true;
        }
    }

    function isUndefined(input) {
        return input === void 0;
    }

    function isNumber(input) {
        return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
    }

    function isDate(input) {
        return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
    }

    function map(arr, fn) {
        var res = [],
            i;
        for (i = 0; i < arr.length; ++i) {
            res.push(fn(arr[i], i));
        }
        return res;
    }

    function hasOwnProp(a, b) {
        return Object.prototype.hasOwnProperty.call(a, b);
    }

    function extend(a, b) {
        for (var i in b) {
            if (hasOwnProp(b, i)) {
                a[i] = b[i];
            }
        }

        if (hasOwnProp(b, 'toString')) {
            a.toString = b.toString;
        }

        if (hasOwnProp(b, 'valueOf')) {
            a.valueOf = b.valueOf;
        }

        return a;
    }

    function createUTC(input, format, locale, strict) {
        return createLocalOrUTC(input, format, locale, strict, true).utc();
    }

    function defaultParsingFlags() {
        // We need to deep clone this object.
        return {
            empty: false,
            unusedTokens: [],
            unusedInput: [],
            overflow: -2,
            charsLeftOver: 0,
            nullInput: false,
            invalidMonth: null,
            invalidFormat: false,
            userInvalidated: false,
            iso: false,
            parsedDateParts: [],
            meridiem: null,
            rfc2822: false,
            weekdayMismatch: false
        };
    }

    function getParsingFlags(m) {
        if (m._pf == null) {
            m._pf = defaultParsingFlags();
        }
        return m._pf;
    }

    var some;
    if (Array.prototype.some) {
        some = Array.prototype.some;
    } else {
        some = function (fun) {
            var t = Object(this);
            var len = t.length >>> 0;

            for (var i = 0; i < len; i++) {
                if (i in t && fun.call(this, t[i], i, t)) {
                    return true;
                }
            }

            return false;
        };
    }

    function isValid(m) {
        if (m._isValid == null) {
            var flags = getParsingFlags(m);
            var parsedParts = some.call(flags.parsedDateParts, function (i) {
                return i != null;
            });
            var isNowValid = !isNaN(m._d.getTime()) &&
                flags.overflow < 0 &&
                !flags.empty &&
                !flags.invalidMonth &&
                !flags.invalidWeekday &&
                !flags.weekdayMismatch &&
                !flags.nullInput &&
                !flags.invalidFormat &&
                !flags.userInvalidated &&
                (!flags.meridiem || (flags.meridiem && parsedParts));

            if (m._strict) {
                isNowValid = isNowValid &&
                    flags.charsLeftOver === 0 &&
                    flags.unusedTokens.length === 0 &&
                    flags.bigHour === undefined;
            }

            if (Object.isFrozen == null || !Object.isFrozen(m)) {
                m._isValid = isNowValid;
            } else {
                return isNowValid;
            }
        }
        return m._isValid;
    }

    function createInvalid(flags) {
        var m = createUTC(NaN);
        if (flags != null) {
            extend(getParsingFlags(m), flags);
        } else {
            getParsingFlags(m).userInvalidated = true;
        }

        return m;
    }

    // Plugins that add properties should also add the key here (null value),
    // so we can properly clone ourselves.
    var momentProperties = hooks.momentProperties = [];

    function copyConfig(to, from) {
        var i, prop, val;

        if (!isUndefined(from._isAMomentObject)) {
            to._isAMomentObject = from._isAMomentObject;
        }
        if (!isUndefined(from._i)) {
            to._i = from._i;
        }
        if (!isUndefined(from._f)) {
            to._f = from._f;
        }
        if (!isUndefined(from._l)) {
            to._l = from._l;
        }
        if (!isUndefined(from._strict)) {
            to._strict = from._strict;
        }
        if (!isUndefined(from._tzm)) {
            to._tzm = from._tzm;
        }
        if (!isUndefined(from._isUTC)) {
            to._isUTC = from._isUTC;
        }
        if (!isUndefined(from._offset)) {
            to._offset = from._offset;
        }
        if (!isUndefined(from._pf)) {
            to._pf = getParsingFlags(from);
        }
        if (!isUndefined(from._locale)) {
            to._locale = from._locale;
        }

        if (momentProperties.length > 0) {
            for (i = 0; i < momentProperties.length; i++) {
                prop = momentProperties[i];
                val = from[prop];
                if (!isUndefined(val)) {
                    to[prop] = val;
                }
            }
        }

        return to;
    }

    var updateInProgress = false;

    // Moment prototype object
    function Moment(config) {
        copyConfig(this, config);
        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
        if (!this.isValid()) {
            this._d = new Date(NaN);
        }
        // Prevent infinite loop in case updateOffset creates new moment
        // objects.
        if (updateInProgress === false) {
            updateInProgress = true;
            hooks.updateOffset(this);
            updateInProgress = false;
        }
    }

    function isMoment(obj) {
        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
    }

    function absFloor(number) {
        if (number < 0) {
            // -0 -> 0
            return Math.ceil(number) || 0;
        } else {
            return Math.floor(number);
        }
    }

    function toInt(argumentForCoercion) {
        var coercedNumber = +argumentForCoercion,
            value = 0;

        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
            value = absFloor(coercedNumber);
        }

        return value;
    }

    // compare two arrays, return the number of differences
    function compareArrays(array1, array2, dontConvert) {
        var len = Math.min(array1.length, array2.length),
            lengthDiff = Math.abs(array1.length - array2.length),
            diffs = 0,
            i;
        for (i = 0; i < len; i++) {
            if ((dontConvert && array1[i] !== array2[i]) ||
                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
                diffs++;
            }
        }
        return diffs + lengthDiff;
    }

    function warn(msg) {
        if (hooks.suppressDeprecationWarnings === false &&
            (typeof console !== 'undefined') && console.warn) {
            console.warn('Deprecation warning: ' + msg);
        }
    }

    function deprecate(msg, fn) {
        var firstTime = true;

        return extend(function () {
            if (hooks.deprecationHandler != null) {
                hooks.deprecationHandler(null, msg);
            }
            if (firstTime) {
                var args = [];
                var arg;
                for (var i = 0; i < arguments.length; i++) {
                    arg = '';
                    if (typeof arguments[i] === 'object') {
                        arg += '\n[' + i + '] ';
                        for (var key in arguments[0]) {
                            arg += key + ': ' + arguments[0][key] + ', ';
                        }
                        arg = arg.slice(0, -2); // Remove trailing comma and space
                    } else {
                        arg = arguments[i];
                    }
                    args.push(arg);
                }
                warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (
                    new Error()).stack);
                firstTime = false;
            }
            return fn.apply(this, arguments);
        }, fn);
    }

    var deprecations = {};

    function deprecateSimple(name, msg) {
        if (hooks.deprecationHandler != null) {
            hooks.deprecationHandler(name, msg);
        }
        if (!deprecations[name]) {
            warn(msg);
            deprecations[name] = true;
        }
    }

    hooks.suppressDeprecationWarnings = false;
    hooks.deprecationHandler = null;

    function isFunction(input) {
        return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
    }

    function set(config) {
        var prop, i;
        for (i in config) {
            prop = config[i];
            if (isFunction(prop)) {
                this[i] = prop;
            } else {
                this['_' + i] = prop;
            }
        }
        this._config = config;
        // Lenient ordinal parsing accepts just a number in addition to
        // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
        // TODO: Remove "ordinalParse" fallback in next major release.
        this._dayOfMonthOrdinalParseLenient = new RegExp(
            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
            '|' + (/\d{1,2}/).source);
    }

    function mergeConfigs(parentConfig, childConfig) {
        var res = extend({}, parentConfig),
            prop;
        for (prop in childConfig) {
            if (hasOwnProp(childConfig, prop)) {
                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
                    res[prop] = {};
                    extend(res[prop], parentConfig[prop]);
                    extend(res[prop], childConfig[prop]);
                } else if (childConfig[prop] != null) {
                    res[prop] = childConfig[prop];
                } else {
                    delete res[prop];
                }
            }
        }
        for (prop in parentConfig) {
            if (hasOwnProp(parentConfig, prop) &&
                !hasOwnProp(childConfig, prop) &&
                isObject(parentConfig[prop])) {
                // make sure changes to properties don't modify parent config
                res[prop] = extend({}, res[prop]);
            }
        }
        return res;
    }

    function Locale(config) {
        if (config != null) {
            this.set(config);
        }
    }

    var keys;

    if (Object.keys) {
        keys = Object.keys;
    } else {
        keys = function (obj) {
            var i, res = [];
            for (i in obj) {
                if (hasOwnProp(obj, i)) {
                    res.push(i);
                }
            }
            return res;
        };
    }

    var defaultCalendar = {
        sameDay: '[Today at] LT',
        nextDay: '[Tomorrow at] LT',
        nextWeek: 'dddd [at] LT',
        lastDay: '[Yesterday at] LT',
        lastWeek: '[Last] dddd [at] LT',
        sameElse: 'L'
    };

    function calendar(key, mom, now) {
        var output = this._calendar[key] || this._calendar['sameElse'];
        return isFunction(output) ? output.call(mom, now) : output;
    }

    var defaultLongDateFormat = {
        LTS: 'h:mm:ss A',
        LT: 'h:mm A',
        L: 'MM/DD/YYYY',
        LL: 'MMMM D, YYYY',
        LLL: 'MMMM D, YYYY h:mm A',
        LLLL: 'dddd, MMMM D, YYYY h:mm A'
    };

    function longDateFormat(key) {
        var format = this._longDateFormat[key],
            formatUpper = this._longDateFormat[key.toUpperCase()];

        if (format || !formatUpper) {
            return format;
        }

        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
            return val.slice(1);
        });

        return this._longDateFormat[key];
    }

    var defaultInvalidDate = 'Invalid date';

    function invalidDate() {
        return this._invalidDate;
    }

    var defaultOrdinal = '%d';
    var defaultDayOfMonthOrdinalParse = /\d{1,2}/;

    function ordinal(number) {
        return this._ordinal.replace('%d', number);
    }

    var defaultRelativeTime = {
        future: 'in %s',
        past: '%s ago',
        s: 'a few seconds',
        ss: '%d seconds',
        m: 'a minute',
        mm: '%d minutes',
        h: 'an hour',
        hh: '%d hours',
        d: 'a day',
        dd: '%d days',
        M: 'a month',
        MM: '%d months',
        y: 'a year',
        yy: '%d years'
    };

    function relativeTime(number, withoutSuffix, string, isFuture) {
        var output = this._relativeTime[string];
        return (isFunction(output)) ?
            output(number, withoutSuffix, string, isFuture) :
            output.replace(/%d/i, number);
    }

    function pastFuture(diff, output) {
        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
        return isFunction(format) ? format(output) : format.replace(/%s/i, output);
    }

    var aliases = {};

    function addUnitAlias(unit, shorthand) {
        var lowerCase = unit.toLowerCase();
        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
    }

    function normalizeUnits(units) {
        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
    }

    function normalizeObjectUnits(inputObject) {
        var normalizedInput = {},
            normalizedProp,
            prop;

        for (prop in inputObject) {
            if (hasOwnProp(inputObject, prop)) {
                normalizedProp = normalizeUnits(prop);
                if (normalizedProp) {
                    normalizedInput[normalizedProp] = inputObject[prop];
                }
            }
        }

        return normalizedInput;
    }

    var priorities = {};

    function addUnitPriority(unit, priority) {
        priorities[unit] = priority;
    }

    function getPrioritizedUnits(unitsObj) {
        var units = [];
        for (var u in unitsObj) {
            units.push({
                unit: u,
                priority: priorities[u]
            });
        }
        units.sort(function (a, b) {
            return a.priority - b.priority;
        });
        return units;
    }

    function zeroFill(number, targetLength, forceSign) {
        var absNumber = '' + Math.abs(number),
            zerosToFill = targetLength - absNumber.length,
            sign = number >= 0;
        return (sign ? (forceSign ? '+' : '') : '-') +
            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
    }

    var formattingTokens =
        /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;

    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;

    var formatFunctions = {};

    var formatTokenFunctions = {};

    // token:    'M'
    // padded:   ['MM', 2]
    // ordinal:  'Mo'
    // callback: function () { this.month() + 1 }
    function addFormatToken(token, padded, ordinal, callback) {
        var func = callback;
        if (typeof callback === 'string') {
            func = function () {
                return this[callback]();
            };
        }
        if (token) {
            formatTokenFunctions[token] = func;
        }
        if (padded) {
            formatTokenFunctions[padded[0]] = function () {
                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
            };
        }
        if (ordinal) {
            formatTokenFunctions[ordinal] = function () {
                return this.localeData().ordinal(func.apply(this, arguments), token);
            };
        }
    }

    function removeFormattingTokens(input) {
        if (input.match(/\[[\s\S]/)) {
            return input.replace(/^\[|\]$/g, '');
        }
        return input.replace(/\\/g, '');
    }

    function makeFormatFunction(format) {
        var array = format.match(formattingTokens),
            i, length;

        for (i = 0, length = array.length; i < length; i++) {
            if (formatTokenFunctions[array[i]]) {
                array[i] = formatTokenFunctions[array[i]];
            } else {
                array[i] = removeFormattingTokens(array[i]);
            }
        }

        return function (mom) {
            var output = '',
                i;
            for (i = 0; i < length; i++) {
                output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
            }
            return output;
        };
    }

    // format date using native date object
    function formatMoment(m, format) {
        if (!m.isValid()) {
            return m.localeData().invalidDate();
        }

        format = expandFormat(format, m.localeData());
        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);

        return formatFunctions[format](m);
    }

    function expandFormat(format, locale) {
        var i = 5;

        function replaceLongDateFormatTokens(input) {
            return locale.longDateFormat(input) || input;
        }

        localFormattingTokens.lastIndex = 0;
        while (i >= 0 && localFormattingTokens.test(format)) {
            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
            localFormattingTokens.lastIndex = 0;
            i -= 1;
        }

        return format;
    }

    var match1 = /\d/; //       0 - 9
    var match2 = /\d\d/; //      00 - 99
    var match3 = /\d{3}/; //     000 - 999
    var match4 = /\d{4}/; //    0000 - 9999
    var match6 = /[+-]?\d{6}/; // -999999 - 999999
    var match1to2 = /\d\d?/; //       0 - 99
    var match3to4 = /\d\d\d\d?/; //     999 - 9999
    var match5to6 = /\d\d\d\d\d\d?/; //   99999 - 999999
    var match1to3 = /\d{1,3}/; //       0 - 999
    var match1to4 = /\d{1,4}/; //       0 - 9999
    var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999

    var matchUnsigned = /\d+/; //       0 - inf
    var matchSigned = /[+-]?\d+/; //    -inf - inf

    var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
    var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z

    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123

    // any word (or two) characters or numbers including two/three word month in arabic.
    // includes scottish gaelic two word and hyphenated months
    var matchWord =
        /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;

    var regexes = {};

    function addRegexToken(token, regex, strictRegex) {
        regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
            return (isStrict && strictRegex) ? strictRegex : regex;
        };
    }

    function getParseRegexForToken(token, config) {
        if (!hasOwnProp(regexes, token)) {
            return new RegExp(unescapeFormat(token));
        }

        return regexes[token](config._strict, config._locale);
    }

    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
    function unescapeFormat(s) {
        return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (
            matched, p1, p2, p3, p4) {
            return p1 || p2 || p3 || p4;
        }));
    }

    function regexEscape(s) {
        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
    }

    var tokens = {};

    function addParseToken(token, callback) {
        var i, func = callback;
        if (typeof token === 'string') {
            token = [token];
        }
        if (isNumber(callback)) {
            func = function (input, array) {
                array[callback] = toInt(input);
            };
        }
        for (i = 0; i < token.length; i++) {
            tokens[token[i]] = func;
        }
    }

    function addWeekParseToken(token, callback) {
        addParseToken(token, function (input, array, config, token) {
            config._w = config._w || {};
            callback(input, config._w, config, token);
        });
    }

    function addTimeToArrayFromToken(token, input, config) {
        if (input != null && hasOwnProp(tokens, token)) {
            tokens[token](input, config._a, config, token);
        }
    }

    var YEAR = 0;
    var MONTH = 1;
    var DATE = 2;
    var HOUR = 3;
    var MINUTE = 4;
    var SECOND = 5;
    var MILLISECOND = 6;
    var WEEK = 7;
    var WEEKDAY = 8;

    // FORMATTING

    addFormatToken('Y', 0, 0, function () {
        var y = this.year();
        return y <= 9999 ? '' + y : '+' + y;
    });

    addFormatToken(0, ['YY', 2], 0, function () {
        return this.year() % 100;
    });

    addFormatToken(0, ['YYYY', 4], 0, 'year');
    addFormatToken(0, ['YYYYY', 5], 0, 'year');
    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');

    // ALIASES

    addUnitAlias('year', 'y');

    // PRIORITIES

    addUnitPriority('year', 1);

    // PARSING

    addRegexToken('Y', matchSigned);
    addRegexToken('YY', match1to2, match2);
    addRegexToken('YYYY', match1to4, match4);
    addRegexToken('YYYYY', match1to6, match6);
    addRegexToken('YYYYYY', match1to6, match6);

    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
    addParseToken('YYYY', function (input, array) {
        array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
    });
    addParseToken('YY', function (input, array) {
        array[YEAR] = hooks.parseTwoDigitYear(input);
    });
    addParseToken('Y', function (input, array) {
        array[YEAR] = parseInt(input, 10);
    });

    // HELPERS

    function daysInYear(year) {
        return isLeapYear(year) ? 366 : 365;
    }

    function isLeapYear(year) {
        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
    }

    // HOOKS

    hooks.parseTwoDigitYear = function (input) {
        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
    };

    // MOMENTS

    var getSetYear = makeGetSet('FullYear', true);

    function getIsLeapYear() {
        return isLeapYear(this.year());
    }

    function makeGetSet(unit, keepTime) {
        return function (value) {
            if (value != null) {
                set$1(this, unit, value);
                hooks.updateOffset(this, keepTime);
                return this;
            } else {
                return get(this, unit);
            }
        };
    }

    function get(mom, unit) {
        return mom.isValid() ?
            mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
    }

    function set$1(mom, unit, value) {
        if (mom.isValid() && !isNaN(value)) {
            if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom
                    .month()));
            } else {
                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
            }
        }
    }

    // MOMENTS

    function stringGet(units) {
        units = normalizeUnits(units);
        if (isFunction(this[units])) {
            return this[units]();
        }
        return this;
    }


    function stringSet(units, value) {
        if (typeof units === 'object') {
            units = normalizeObjectUnits(units);
            var prioritized = getPrioritizedUnits(units);
            for (var i = 0; i < prioritized.length; i++) {
                this[prioritized[i].unit](units[prioritized[i].unit]);
            }
        } else {
            units = normalizeUnits(units);
            if (isFunction(this[units])) {
                return this[units](value);
            }
        }
        return this;
    }

    function mod(n, x) {
        return ((n % x) + x) % x;
    }

    var indexOf;

    if (Array.prototype.indexOf) {
        indexOf = Array.prototype.indexOf;
    } else {
        indexOf = function (o) {
            // I know
            var i;
            for (i = 0; i < this.length; ++i) {
                if (this[i] === o) {
                    return i;
                }
            }
            return -1;
        };
    }

    function daysInMonth(year, month) {
        if (isNaN(year) || isNaN(month)) {
            return NaN;
        }
        var modMonth = mod(month, 12);
        year += (month - modMonth) / 12;
        return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
    }

    // FORMATTING

    addFormatToken('M', ['MM', 2], 'Mo', function () {
        return this.month() + 1;
    });

    addFormatToken('MMM', 0, 0, function (format) {
        return this.localeData().monthsShort(this, format);
    });

    addFormatToken('MMMM', 0, 0, function (format) {
        return this.localeData().months(this, format);
    });

    // ALIASES

    addUnitAlias('month', 'M');

    // PRIORITY

    addUnitPriority('month', 8);

    // PARSING

    addRegexToken('M', match1to2);
    addRegexToken('MM', match1to2, match2);
    addRegexToken('MMM', function (isStrict, locale) {
        return locale.monthsShortRegex(isStrict);
    });
    addRegexToken('MMMM', function (isStrict, locale) {
        return locale.monthsRegex(isStrict);
    });

    addParseToken(['M', 'MM'], function (input, array) {
        array[MONTH] = toInt(input) - 1;
    });

    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
        var month = config._locale.monthsParse(input, token, config._strict);
        // if we didn't find a month name, mark the date as invalid.
        if (month != null) {
            array[MONTH] = month;
        } else {
            getParsingFlags(config).invalidMonth = input;
        }
    });

    // LOCALES

    var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
    var defaultLocaleMonths =
        'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');

    function localeMonths(m, format) {
        if (!m) {
            return isArray(this._months) ? this._months :
                this._months['standalone'];
        }
        return isArray(this._months) ? this._months[m.month()] :
            this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone']
                [m.month()];
    }

    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');

    function localeMonthsShort(m, format) {
        if (!m) {
            return isArray(this._monthsShort) ? this._monthsShort :
                this._monthsShort['standalone'];
        }
        return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
            this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
    }

    function handleStrictParse(monthName, format, strict) {
        var i, ii, mom, llc = monthName.toLocaleLowerCase();
        if (!this._monthsParse) {
            // this is not used
            this._monthsParse = [];
            this._longMonthsParse = [];
            this._shortMonthsParse = [];
            for (i = 0; i < 12; ++i) {
                mom = createUTC([2000, i]);
                this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
            }
        }

        if (strict) {
            if (format === 'MMM') {
                ii = indexOf.call(this._shortMonthsParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf.call(this._longMonthsParse, llc);
                return ii !== -1 ? ii : null;
            }
        } else {
            if (format === 'MMM') {
                ii = indexOf.call(this._shortMonthsParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._longMonthsParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf.call(this._longMonthsParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._shortMonthsParse, llc);
                return ii !== -1 ? ii : null;
            }
        }
    }

    function localeMonthsParse(monthName, format, strict) {
        var i, mom, regex;

        if (this._monthsParseExact) {
            return handleStrictParse.call(this, monthName, format, strict);
        }

        if (!this._monthsParse) {
            this._monthsParse = [];
            this._longMonthsParse = [];
            this._shortMonthsParse = [];
        }

        // TODO: add sorting
        // Sorting makes sure if one month (or abbr) is a prefix of another
        // see sorting in computeMonthsParse
        for (i = 0; i < 12; i++) {
            // make the regex if we don't have it already
            mom = createUTC([2000, i]);
            if (strict && !this._longMonthsParse[i]) {
                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$',
                    'i');
                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') +
                    '$', 'i');
            }
            if (!strict && !this._monthsParse[i]) {
                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
            }
            // test the regex
            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
                return i;
            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
                return i;
            } else if (!strict && this._monthsParse[i].test(monthName)) {
                return i;
            }
        }
    }

    // MOMENTS

    function setMonth(mom, value) {
        var dayOfMonth;

        if (!mom.isValid()) {
            // No op
            return mom;
        }

        if (typeof value === 'string') {
            if (/^\d+$/.test(value)) {
                value = toInt(value);
            } else {
                value = mom.localeData().monthsParse(value);
                // TODO: Another silent failure?
                if (!isNumber(value)) {
                    return mom;
                }
            }
        }

        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
        return mom;
    }

    function getSetMonth(value) {
        if (value != null) {
            setMonth(this, value);
            hooks.updateOffset(this, true);
            return this;
        } else {
            return get(this, 'Month');
        }
    }

    function getDaysInMonth() {
        return daysInMonth(this.year(), this.month());
    }

    var defaultMonthsShortRegex = matchWord;

    function monthsShortRegex(isStrict) {
        if (this._monthsParseExact) {
            if (!hasOwnProp(this, '_monthsRegex')) {
                computeMonthsParse.call(this);
            }
            if (isStrict) {
                return this._monthsShortStrictRegex;
            } else {
                return this._monthsShortRegex;
            }
        } else {
            if (!hasOwnProp(this, '_monthsShortRegex')) {
                this._monthsShortRegex = defaultMonthsShortRegex;
            }
            return this._monthsShortStrictRegex && isStrict ?
                this._monthsShortStrictRegex : this._monthsShortRegex;
        }
    }

    var defaultMonthsRegex = matchWord;

    function monthsRegex(isStrict) {
        if (this._monthsParseExact) {
            if (!hasOwnProp(this, '_monthsRegex')) {
                computeMonthsParse.call(this);
            }
            if (isStrict) {
                return this._monthsStrictRegex;
            } else {
                return this._monthsRegex;
            }
        } else {
            if (!hasOwnProp(this, '_monthsRegex')) {
                this._monthsRegex = defaultMonthsRegex;
            }
            return this._monthsStrictRegex && isStrict ?
                this._monthsStrictRegex : this._monthsRegex;
        }
    }

    function computeMonthsParse() {
        function cmpLenRev(a, b) {
            return b.length - a.length;
        }

        var shortPieces = [],
            longPieces = [],
            mixedPieces = [],
            i, mom;
        for (i = 0; i < 12; i++) {
            // make the regex if we don't have it already
            mom = createUTC([2000, i]);
            shortPieces.push(this.monthsShort(mom, ''));
            longPieces.push(this.months(mom, ''));
            mixedPieces.push(this.months(mom, ''));
            mixedPieces.push(this.monthsShort(mom, ''));
        }
        // Sorting makes sure if one month (or abbr) is a prefix of another it
        // will match the longer piece.
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        for (i = 0; i < 12; i++) {
            shortPieces[i] = regexEscape(shortPieces[i]);
            longPieces[i] = regexEscape(longPieces[i]);
        }
        for (i = 0; i < 24; i++) {
            mixedPieces[i] = regexEscape(mixedPieces[i]);
        }

        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
        this._monthsShortRegex = this._monthsRegex;
        this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
        this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
    }

    function createDate(y, m, d, h, M, s, ms) {
        // can't just apply() to create a date:
        // https://stackoverflow.com/q/181348
        var date;
        // the date constructor remaps years 0-99 to 1900-1999
        if (y < 100 && y >= 0) {
            // preserve leap years using a full 400 year cycle, then reset
            date = new Date(y + 400, m, d, h, M, s, ms);
            if (isFinite(date.getFullYear())) {
                date.setFullYear(y);
            }
        } else {
            date = new Date(y, m, d, h, M, s, ms);
        }

        return date;
    }

    function createUTCDate(y) {
        var date;
        // the Date.UTC function remaps years 0-99 to 1900-1999
        if (y < 100 && y >= 0) {
            var args = Array.prototype.slice.call(arguments);
            // preserve leap years using a full 400 year cycle, then reset
            args[0] = y + 400;
            date = new Date(Date.UTC.apply(null, args));
            if (isFinite(date.getUTCFullYear())) {
                date.setUTCFullYear(y);
            }
        } else {
            date = new Date(Date.UTC.apply(null, arguments));
        }

        return date;
    }

    // start-of-first-week - start-of-year
    function firstWeekOffset(year, dow, doy) {
        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
            fwd = 7 + dow - doy,
            // first-week day local weekday -- which local weekday is fwd
            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;

        return -fwdlw + fwd - 1;
    }

    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
        var localWeekday = (7 + weekday - dow) % 7,
            weekOffset = firstWeekOffset(year, dow, doy),
            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
            resYear, resDayOfYear;

        if (dayOfYear <= 0) {
            resYear = year - 1;
            resDayOfYear = daysInYear(resYear) + dayOfYear;
        } else if (dayOfYear > daysInYear(year)) {
            resYear = year + 1;
            resDayOfYear = dayOfYear - daysInYear(year);
        } else {
            resYear = year;
            resDayOfYear = dayOfYear;
        }

        return {
            year: resYear,
            dayOfYear: resDayOfYear
        };
    }

    function weekOfYear(mom, dow, doy) {
        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
            resWeek, resYear;

        if (week < 1) {
            resYear = mom.year() - 1;
            resWeek = week + weeksInYear(resYear, dow, doy);
        } else if (week > weeksInYear(mom.year(), dow, doy)) {
            resWeek = week - weeksInYear(mom.year(), dow, doy);
            resYear = mom.year() + 1;
        } else {
            resYear = mom.year();
            resWeek = week;
        }

        return {
            week: resWeek,
            year: resYear
        };
    }

    function weeksInYear(year, dow, doy) {
        var weekOffset = firstWeekOffset(year, dow, doy),
            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
    }

    // FORMATTING

    addFormatToken('w', ['ww', 2], 'wo', 'week');
    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');

    // ALIASES

    addUnitAlias('week', 'w');
    addUnitAlias('isoWeek', 'W');

    // PRIORITIES

    addUnitPriority('week', 5);
    addUnitPriority('isoWeek', 5);

    // PARSING

    addRegexToken('w', match1to2);
    addRegexToken('ww', match1to2, match2);
    addRegexToken('W', match1to2);
    addRegexToken('WW', match1to2, match2);

    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
        week[token.substr(0, 1)] = toInt(input);
    });

    // HELPERS

    // LOCALES

    function localeWeek(mom) {
        return weekOfYear(mom, this._week.dow, this._week.doy).week;
    }

    var defaultLocaleWeek = {
        dow: 0, // Sunday is the first day of the week.
        doy: 6 // The week that contains Jan 6th is the first week of the year.
    };

    function localeFirstDayOfWeek() {
        return this._week.dow;
    }

    function localeFirstDayOfYear() {
        return this._week.doy;
    }

    // MOMENTS

    function getSetWeek(input) {
        var week = this.localeData().week(this);
        return input == null ? week : this.add((input - week) * 7, 'd');
    }

    function getSetISOWeek(input) {
        var week = weekOfYear(this, 1, 4).week;
        return input == null ? week : this.add((input - week) * 7, 'd');
    }

    // FORMATTING

    addFormatToken('d', 0, 'do', 'day');

    addFormatToken('dd', 0, 0, function (format) {
        return this.localeData().weekdaysMin(this, format);
    });

    addFormatToken('ddd', 0, 0, function (format) {
        return this.localeData().weekdaysShort(this, format);
    });

    addFormatToken('dddd', 0, 0, function (format) {
        return this.localeData().weekdays(this, format);
    });

    addFormatToken('e', 0, 0, 'weekday');
    addFormatToken('E', 0, 0, 'isoWeekday');

    // ALIASES

    addUnitAlias('day', 'd');
    addUnitAlias('weekday', 'e');
    addUnitAlias('isoWeekday', 'E');

    // PRIORITY
    addUnitPriority('day', 11);
    addUnitPriority('weekday', 11);
    addUnitPriority('isoWeekday', 11);

    // PARSING

    addRegexToken('d', match1to2);
    addRegexToken('e', match1to2);
    addRegexToken('E', match1to2);
    addRegexToken('dd', function (isStrict, locale) {
        return locale.weekdaysMinRegex(isStrict);
    });
    addRegexToken('ddd', function (isStrict, locale) {
        return locale.weekdaysShortRegex(isStrict);
    });
    addRegexToken('dddd', function (isStrict, locale) {
        return locale.weekdaysRegex(isStrict);
    });

    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
        var weekday = config._locale.weekdaysParse(input, token, config._strict);
        // if we didn't get a weekday name, mark the date as invalid
        if (weekday != null) {
            week.d = weekday;
        } else {
            getParsingFlags(config).invalidWeekday = input;
        }
    });

    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
        week[token] = toInt(input);
    });

    // HELPERS

    function parseWeekday(input, locale) {
        if (typeof input !== 'string') {
            return input;
        }

        if (!isNaN(input)) {
            return parseInt(input, 10);
        }

        input = locale.weekdaysParse(input);
        if (typeof input === 'number') {
            return input;
        }

        return null;
    }

    function parseIsoWeekday(input, locale) {
        if (typeof input === 'string') {
            return locale.weekdaysParse(input) % 7 || 7;
        }
        return isNaN(input) ? null : input;
    }

    // LOCALES
    function shiftWeekdays(ws, n) {
        return ws.slice(n, 7).concat(ws.slice(0, n));
    }

    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');

    function localeWeekdays(m, format) {
        var weekdays = isArray(this._weekdays) ? this._weekdays :
            this._weekdays[(m && m !== true && this._weekdays.isFormat.test(format)) ? 'format' :
                'standalone'];
        return (m === true) ? shiftWeekdays(weekdays, this._week.dow) :
            (m) ? weekdays[m.day()] : weekdays;
    }

    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');

    function localeWeekdaysShort(m) {
        return (m === true) ? shiftWeekdays(this._weekdaysShort, this._week.dow) :
            (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
    }

    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');

    function localeWeekdaysMin(m) {
        return (m === true) ? shiftWeekdays(this._weekdaysMin, this._week.dow) :
            (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
    }

    function handleStrictParse$1(weekdayName, format, strict) {
        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
        if (!this._weekdaysParse) {
            this._weekdaysParse = [];
            this._shortWeekdaysParse = [];
            this._minWeekdaysParse = [];

            for (i = 0; i < 7; ++i) {
                mom = createUTC([2000, 1]).day(i);
                this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
                this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
            }
        }

        if (strict) {
            if (format === 'dddd') {
                ii = indexOf.call(this._weekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else if (format === 'ddd') {
                ii = indexOf.call(this._shortWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf.call(this._minWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            }
        } else {
            if (format === 'dddd') {
                ii = indexOf.call(this._weekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._shortWeekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._minWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else if (format === 'ddd') {
                ii = indexOf.call(this._shortWeekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._weekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._minWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf.call(this._minWeekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._weekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf.call(this._shortWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            }
        }
    }

    function localeWeekdaysParse(weekdayName, format, strict) {
        var i, mom, regex;

        if (this._weekdaysParseExact) {
            return handleStrictParse$1.call(this, weekdayName, format, strict);
        }

        if (!this._weekdaysParse) {
            this._weekdaysParse = [];
            this._minWeekdaysParse = [];
            this._shortWeekdaysParse = [];
            this._fullWeekdaysParse = [];
        }

        for (i = 0; i < 7; i++) {
            // make the regex if we don't have it already

            mom = createUTC([2000, 1]).day(i);
            if (strict && !this._fullWeekdaysParse[i]) {
                this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') +
                    '$', 'i');
                this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.',
                    '\\.?') + '$', 'i');
                this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') +
                    '$', 'i');
            }
            if (!this._weekdaysParse[i]) {
                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(
                    mom, '');
                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
            }
            // test the regex
            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
                return i;
            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
                return i;
            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
                return i;
            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
                return i;
            }
        }
    }

    // MOMENTS

    function getSetDayOfWeek(input) {
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }
        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
        if (input != null) {
            input = parseWeekday(input, this.localeData());
            return this.add(input - day, 'd');
        } else {
            return day;
        }
    }

    function getSetLocaleDayOfWeek(input) {
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }
        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
        return input == null ? weekday : this.add(input - weekday, 'd');
    }

    function getSetISODayOfWeek(input) {
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }

        // behaves the same as moment#day except
        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
        // as a setter, sunday should belong to the previous week.

        if (input != null) {
            var weekday = parseIsoWeekday(input, this.localeData());
            return this.day(this.day() % 7 ? weekday : weekday - 7);
        } else {
            return this.day() || 7;
        }
    }

    var defaultWeekdaysRegex = matchWord;

    function weekdaysRegex(isStrict) {
        if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                computeWeekdaysParse.call(this);
            }
            if (isStrict) {
                return this._weekdaysStrictRegex;
            } else {
                return this._weekdaysRegex;
            }
        } else {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                this._weekdaysRegex = defaultWeekdaysRegex;
            }
            return this._weekdaysStrictRegex && isStrict ?
                this._weekdaysStrictRegex : this._weekdaysRegex;
        }
    }

    var defaultWeekdaysShortRegex = matchWord;

    function weekdaysShortRegex(isStrict) {
        if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                computeWeekdaysParse.call(this);
            }
            if (isStrict) {
                return this._weekdaysShortStrictRegex;
            } else {
                return this._weekdaysShortRegex;
            }
        } else {
            if (!hasOwnProp(this, '_weekdaysShortRegex')) {
                this._weekdaysShortRegex = defaultWeekdaysShortRegex;
            }
            return this._weekdaysShortStrictRegex && isStrict ?
                this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
        }
    }

    var defaultWeekdaysMinRegex = matchWord;

    function weekdaysMinRegex(isStrict) {
        if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                computeWeekdaysParse.call(this);
            }
            if (isStrict) {
                return this._weekdaysMinStrictRegex;
            } else {
                return this._weekdaysMinRegex;
            }
        } else {
            if (!hasOwnProp(this, '_weekdaysMinRegex')) {
                this._weekdaysMinRegex = defaultWeekdaysMinRegex;
            }
            return this._weekdaysMinStrictRegex && isStrict ?
                this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
        }
    }


    function computeWeekdaysParse() {
        function cmpLenRev(a, b) {
            return b.length - a.length;
        }

        var minPieces = [],
            shortPieces = [],
            longPieces = [],
            mixedPieces = [],
            i, mom, minp, shortp, longp;
        for (i = 0; i < 7; i++) {
            // make the regex if we don't have it already
            mom = createUTC([2000, 1]).day(i);
            minp = this.weekdaysMin(mom, '');
            shortp = this.weekdaysShort(mom, '');
            longp = this.weekdays(mom, '');
            minPieces.push(minp);
            shortPieces.push(shortp);
            longPieces.push(longp);
            mixedPieces.push(minp);
            mixedPieces.push(shortp);
            mixedPieces.push(longp);
        }
        // Sorting makes sure if one weekday (or abbr) is a prefix of another it
        // will match the longer piece.
        minPieces.sort(cmpLenRev);
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        for (i = 0; i < 7; i++) {
            shortPieces[i] = regexEscape(shortPieces[i]);
            longPieces[i] = regexEscape(longPieces[i]);
            mixedPieces[i] = regexEscape(mixedPieces[i]);
        }

        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
        this._weekdaysShortRegex = this._weekdaysRegex;
        this._weekdaysMinRegex = this._weekdaysRegex;

        this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
        this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
        this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
    }

    // FORMATTING

    function hFormat() {
        return this.hours() % 12 || 12;
    }

    function kFormat() {
        return this.hours() || 24;
    }

    addFormatToken('H', ['HH', 2], 0, 'hour');
    addFormatToken('h', ['hh', 2], 0, hFormat);
    addFormatToken('k', ['kk', 2], 0, kFormat);

    addFormatToken('hmm', 0, 0, function () {
        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
    });

    addFormatToken('hmmss', 0, 0, function () {
        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
            zeroFill(this.seconds(), 2);
    });

    addFormatToken('Hmm', 0, 0, function () {
        return '' + this.hours() + zeroFill(this.minutes(), 2);
    });

    addFormatToken('Hmmss', 0, 0, function () {
        return '' + this.hours() + zeroFill(this.minutes(), 2) +
            zeroFill(this.seconds(), 2);
    });

    function meridiem(token, lowercase) {
        addFormatToken(token, 0, 0, function () {
            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
        });
    }

    meridiem('a', true);
    meridiem('A', false);

    // ALIASES

    addUnitAlias('hour', 'h');

    // PRIORITY
    addUnitPriority('hour', 13);

    // PARSING

    function matchMeridiem(isStrict, locale) {
        return locale._meridiemParse;
    }

    addRegexToken('a', matchMeridiem);
    addRegexToken('A', matchMeridiem);
    addRegexToken('H', match1to2);
    addRegexToken('h', match1to2);
    addRegexToken('k', match1to2);
    addRegexToken('HH', match1to2, match2);
    addRegexToken('hh', match1to2, match2);
    addRegexToken('kk', match1to2, match2);

    addRegexToken('hmm', match3to4);
    addRegexToken('hmmss', match5to6);
    addRegexToken('Hmm', match3to4);
    addRegexToken('Hmmss', match5to6);

    addParseToken(['H', 'HH'], HOUR);
    addParseToken(['k', 'kk'], function (input, array, config) {
        var kInput = toInt(input);
        array[HOUR] = kInput === 24 ? 0 : kInput;
    });
    addParseToken(['a', 'A'], function (input, array, config) {
        config._isPm = config._locale.isPM(input);
        config._meridiem = input;
    });
    addParseToken(['h', 'hh'], function (input, array, config) {
        array[HOUR] = toInt(input);
        getParsingFlags(config).bigHour = true;
    });
    addParseToken('hmm', function (input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
        getParsingFlags(config).bigHour = true;
    });
    addParseToken('hmmss', function (input, array, config) {
        var pos1 = input.length - 4;
        var pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
        getParsingFlags(config).bigHour = true;
    });
    addParseToken('Hmm', function (input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
    });
    addParseToken('Hmmss', function (input, array, config) {
        var pos1 = input.length - 4;
        var pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
    });

    // LOCALES

    function localeIsPM(input) {
        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
        // Using charAt should be more compatible.
        return ((input + '').toLowerCase().charAt(0) === 'p');
    }

    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;

    function localeMeridiem(hours, minutes, isLower) {
        if (hours > 11) {
            return isLower ? 'pm' : 'PM';
        } else {
            return isLower ? 'am' : 'AM';
        }
    }


    // MOMENTS

    // Setting the hour should keep the time, because the user explicitly
    // specified which hour they want. So trying to maintain the same hour (in
    // a new timezone) makes sense. Adding/subtracting hours does not follow
    // this rule.
    var getSetHour = makeGetSet('Hours', true);

    var baseConfig = {
        calendar: defaultCalendar,
        longDateFormat: defaultLongDateFormat,
        invalidDate: defaultInvalidDate,
        ordinal: defaultOrdinal,
        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
        relativeTime: defaultRelativeTime,

        months: defaultLocaleMonths,
        monthsShort: defaultLocaleMonthsShort,

        week: defaultLocaleWeek,

        weekdays: defaultLocaleWeekdays,
        weekdaysMin: defaultLocaleWeekdaysMin,
        weekdaysShort: defaultLocaleWeekdaysShort,

        meridiemParse: defaultLocaleMeridiemParse
    };

    // internal storage for locale config files
    var locales = {};
    var localeFamilies = {};
    var globalLocale;

    function normalizeLocale(key) {
        return key ? key.toLowerCase().replace('_', '-') : key;
    }

    // pick the locale from the array
    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
    function chooseLocale(names) {
        var i = 0,
            j, next, locale, split;

        while (i < names.length) {
            split = normalizeLocale(names[i]).split('-');
            j = split.length;
            next = normalizeLocale(names[i + 1]);
            next = next ? next.split('-') : null;
            while (j > 0) {
                locale = loadLocale(split.slice(0, j).join('-'));
                if (locale) {
                    return locale;
                }
                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
                    //the next array item is better than a shallower substring of this one
                    break;
                }
                j--;
            }
            i++;
        }
        return globalLocale;
    }

    function loadLocale(name) {
        var oldLocale = null;
        // TODO: Find a better way to register and load all the locales in Node
        if (!locales[name] && (typeof module !== 'undefined') &&
            module && module.exports) {
            try {
                oldLocale = globalLocale._abbr;
                var aliasedRequire = require;
                aliasedRequire('./locale/' + name);
                getSetGlobalLocale(oldLocale);
            } catch (e) {}
        }
        return locales[name];
    }

    // This function will load locale and then set the global locale.  If
    // no arguments are passed in, it will simply return the current global
    // locale key.
    function getSetGlobalLocale(key, values) {
        var data;
        if (key) {
            if (isUndefined(values)) {
                data = getLocale(key);
            } else {
                data = defineLocale(key, values);
            }

            if (data) {
                // moment.duration._locale = moment._locale = data;
                globalLocale = data;
            } else {
                if ((typeof console !== 'undefined') && console.warn) {
                    //warn user if arguments are passed but the locale could not be set
                    console.warn('Locale ' + key + ' not found. Did you forget to load it?');
                }
            }
        }

        return globalLocale._abbr;
    }

    function defineLocale(name, config) {
        if (config !== null) {
            var locale, parentConfig = baseConfig;
            config.abbr = name;
            if (locales[name] != null) {
                deprecateSimple('defineLocaleOverride',
                    'use moment.updateLocale(localeName, config) to change ' +
                    'an existing locale. moment.defineLocale(localeName, ' +
                    'config) should only be used for creating a new locale ' +
                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
                parentConfig = locales[name]._config;
            } else if (config.parentLocale != null) {
                if (locales[config.parentLocale] != null) {
                    parentConfig = locales[config.parentLocale]._config;
                } else {
                    locale = loadLocale(config.parentLocale);
                    if (locale != null) {
                        parentConfig = locale._config;
                    } else {
                        if (!localeFamilies[config.parentLocale]) {
                            localeFamilies[config.parentLocale] = [];
                        }
                        localeFamilies[config.parentLocale].push({
                            name: name,
                            config: config
                        });
                        return null;
                    }
                }
            }
            locales[name] = new Locale(mergeConfigs(parentConfig, config));

            if (localeFamilies[name]) {
                localeFamilies[name].forEach(function (x) {
                    defineLocale(x.name, x.config);
                });
            }

            // backwards compat for now: also set the locale
            // make sure we set the locale AFTER all child locales have been
            // created, so we won't end up with the child locale set.
            getSetGlobalLocale(name);


            return locales[name];
        } else {
            // useful for testing
            delete locales[name];
            return null;
        }
    }

    function updateLocale(name, config) {
        if (config != null) {
            var locale, tmpLocale, parentConfig = baseConfig;
            // MERGE
            tmpLocale = loadLocale(name);
            if (tmpLocale != null) {
                parentConfig = tmpLocale._config;
            }
            config = mergeConfigs(parentConfig, config);
            locale = new Locale(config);
            locale.parentLocale = locales[name];
            locales[name] = locale;

            // backwards compat for now: also set the locale
            getSetGlobalLocale(name);
        } else {
            // pass null for config to unupdate, useful for tests
            if (locales[name] != null) {
                if (locales[name].parentLocale != null) {
                    locales[name] = locales[name].parentLocale;
                } else if (locales[name] != null) {
                    delete locales[name];
                }
            }
        }
        return locales[name];
    }

    // returns locale data
    function getLocale(key) {
        var locale;

        if (key && key._locale && key._locale._abbr) {
            key = key._locale._abbr;
        }

        if (!key) {
            return globalLocale;
        }

        if (!isArray(key)) {
            //short-circuit everything else
            locale = loadLocale(key);
            if (locale) {
                return locale;
            }
            key = [key];
        }

        return chooseLocale(key);
    }

    function listLocales() {
        return keys(locales);
    }

    function checkOverflow(m) {
        var overflow;
        var a = m._a;

        if (a && getParsingFlags(m).overflow === -2) {
            overflow =
                a[MONTH] < 0 || a[MONTH] > 11 ? MONTH :
                    a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
                        a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[
                            MILLISECOND] !== 0)) ? HOUR :
                            a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE :
                                a[SECOND] < 0 || a[SECOND] > 59 ? SECOND :
                                    a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
                                        -1;

            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
                overflow = DATE;
            }
            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
                overflow = WEEK;
            }
            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
                overflow = WEEKDAY;
            }

            getParsingFlags(m).overflow = overflow;
        }

        return m;
    }

    // Pick the first defined of two or three arguments.
    function defaults(a, b, c) {
        if (a != null) {
            return a;
        }
        if (b != null) {
            return b;
        }
        return c;
    }

    function currentDateArray(config) {
        // hooks is actually the exported moment object
        var nowValue = new Date(hooks.now());
        if (config._useUTC) {
            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
        }
        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
    }

    // convert an array to a date.
    // the array should mirror the parameters below
    // note: all values past the year are optional and will default to the lowest possible value.
    // [year, month, day , hour, minute, second, millisecond]
    function configFromArray(config) {
        var i, date, input = [],
            currentDate, expectedWeekday, yearToUse;

        if (config._d) {
            return;
        }

        currentDate = currentDateArray(config);

        //compute day of the year from weeks and weekdays
        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
            dayOfYearFromWeekInfo(config);
        }

        //if the day of the year is set, figure out what it is
        if (config._dayOfYear != null) {
            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);

            if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
                getParsingFlags(config)._overflowDayOfYear = true;
            }

            date = createUTCDate(yearToUse, 0, config._dayOfYear);
            config._a[MONTH] = date.getUTCMonth();
            config._a[DATE] = date.getUTCDate();
        }

        // Default to current date.
        // * if no year, month, day of month are given, default to today
        // * if day of month is given, default month and year
        // * if month is given, default only year
        // * if year is given, don't default anything
        for (i = 0; i < 3 && config._a[i] == null; ++i) {
            config._a[i] = input[i] = currentDate[i];
        }

        // Zero out whatever was not defaulted, including time
        for (; i < 7; i++) {
            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
        }

        // Check for 24:00:00.000
        if (config._a[HOUR] === 24 &&
            config._a[MINUTE] === 0 &&
            config._a[SECOND] === 0 &&
            config._a[MILLISECOND] === 0) {
            config._nextDay = true;
            config._a[HOUR] = 0;
        }

        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();

        // Apply timezone offset from input. The actual utcOffset can be changed
        // with parseZone.
        if (config._tzm != null) {
            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
        }

        if (config._nextDay) {
            config._a[HOUR] = 24;
        }

        // check for mismatching day of week
        if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
            getParsingFlags(config).weekdayMismatch = true;
        }
    }

    function dayOfYearFromWeekInfo(config) {
        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;

        w = config._w;
        if (w.GG != null || w.W != null || w.E != null) {
            dow = 1;
            doy = 4;

            // TODO: We need to take the current isoWeekYear, but that depends on
            // how we interpret now (local, utc, fixed offset). So create
            // a now version of current config (take local/utc/offset flags, and
            // create now).
            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
            week = defaults(w.W, 1);
            weekday = defaults(w.E, 1);
            if (weekday < 1 || weekday > 7) {
                weekdayOverflow = true;
            }
        } else {
            dow = config._locale._week.dow;
            doy = config._locale._week.doy;

            var curWeek = weekOfYear(createLocal(), dow, doy);

            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);

            // Default to current week.
            week = defaults(w.w, curWeek.week);

            if (w.d != null) {
                // weekday -- low day numbers are considered next week
                weekday = w.d;
                if (weekday < 0 || weekday > 6) {
                    weekdayOverflow = true;
                }
            } else if (w.e != null) {
                // local weekday -- counting starts from beginning of week
                weekday = w.e + dow;
                if (w.e < 0 || w.e > 6) {
                    weekdayOverflow = true;
                }
            } else {
                // default to beginning of week
                weekday = dow;
            }
        }
        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
            getParsingFlags(config)._overflowWeeks = true;
        } else if (weekdayOverflow != null) {
            getParsingFlags(config)._overflowWeekday = true;
        } else {
            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
            config._a[YEAR] = temp.year;
            config._dayOfYear = temp.dayOfYear;
        }
    }

    // iso 8601 regex
    // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
    var extendedIsoRegex =
        /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
    var basicIsoRegex =
        /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;

    var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;

    var isoDates = [
        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
        ['YYYY-DDD', /\d{4}-\d{3}/],
        ['YYYY-MM', /\d{4}-\d\d/, false],
        ['YYYYYYMMDD', /[+-]\d{10}/],
        ['YYYYMMDD', /\d{8}/],
        // YYYYMM is NOT allowed by the standard
        ['GGGG[W]WWE', /\d{4}W\d{3}/],
        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
        ['YYYYDDD', /\d{7}/]
    ];

    // iso time formats and regexes
    var isoTimes = [
        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
        ['HH:mm', /\d\d:\d\d/],
        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
        ['HHmmss', /\d\d\d\d\d\d/],
        ['HHmm', /\d\d\d\d/],
        ['HH', /\d\d/]
    ];

    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;

    // date from iso format
    function configFromISO(config) {
        var i, l,
            string = config._i,
            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
            allowTime, dateFormat, timeFormat, tzFormat;

        if (match) {
            getParsingFlags(config).iso = true;

            for (i = 0, l = isoDates.length; i < l; i++) {
                if (isoDates[i][1].exec(match[1])) {
                    dateFormat = isoDates[i][0];
                    allowTime = isoDates[i][2] !== false;
                    break;
                }
            }
            if (dateFormat == null) {
                config._isValid = false;
                return;
            }
            if (match[3]) {
                for (i = 0, l = isoTimes.length; i < l; i++) {
                    if (isoTimes[i][1].exec(match[3])) {
                        // match[2] should be 'T' or space
                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
                        break;
                    }
                }
                if (timeFormat == null) {
                    config._isValid = false;
                    return;
                }
            }
            if (!allowTime && timeFormat != null) {
                config._isValid = false;
                return;
            }
            if (match[4]) {
                if (tzRegex.exec(match[4])) {
                    tzFormat = 'Z';
                } else {
                    config._isValid = false;
                    return;
                }
            }
            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
            configFromStringAndFormat(config);
        } else {
            config._isValid = false;
        }
    }

    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
    var rfc2822 =
        /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;

    function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
        var result = [
            untruncateYear(yearStr),
            defaultLocaleMonthsShort.indexOf(monthStr),
            parseInt(dayStr, 10),
            parseInt(hourStr, 10),
            parseInt(minuteStr, 10)
        ];

        if (secondStr) {
            result.push(parseInt(secondStr, 10));
        }

        return result;
    }

    function untruncateYear(yearStr) {
        var year = parseInt(yearStr, 10);
        if (year <= 49) {
            return 2000 + year;
        } else if (year <= 999) {
            return 1900 + year;
        }
        return year;
    }

    function preprocessRFC2822(s) {
        // Remove comments and folding whitespace and replace multiple-spaces with a single space
        return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(
            /\s\s*$/, '');
    }

    function checkWeekday(weekdayStr, parsedInput, config) {
        if (weekdayStr) {
            // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
                weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
            if (weekdayProvided !== weekdayActual) {
                getParsingFlags(config).weekdayMismatch = true;
                config._isValid = false;
                return false;
            }
        }
        return true;
    }

    var obsOffsets = {
        UT: 0,
        GMT: 0,
        EDT: -4 * 60,
        EST: -5 * 60,
        CDT: -5 * 60,
        CST: -6 * 60,
        MDT: -6 * 60,
        MST: -7 * 60,
        PDT: -7 * 60,
        PST: -8 * 60
    };

    function calculateOffset(obsOffset, militaryOffset, numOffset) {
        if (obsOffset) {
            return obsOffsets[obsOffset];
        } else if (militaryOffset) {
            // the only allowed military tz is Z
            return 0;
        } else {
            var hm = parseInt(numOffset, 10);
            var m = hm % 100,
                h = (hm - m) / 100;
            return h * 60 + m;
        }
    }

    // date and time from ref 2822 format
    function configFromRFC2822(config) {
        var match = rfc2822.exec(preprocessRFC2822(config._i));
        if (match) {
            var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6],
                match[7]);
            if (!checkWeekday(match[1], parsedArray, config)) {
                return;
            }

            config._a = parsedArray;
            config._tzm = calculateOffset(match[8], match[9], match[10]);

            config._d = createUTCDate.apply(null, config._a);
            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);

            getParsingFlags(config).rfc2822 = true;
        } else {
            config._isValid = false;
        }
    }

    // date from iso format or fallback
    function configFromString(config) {
        var matched = aspNetJsonRegex.exec(config._i);

        if (matched !== null) {
            config._d = new Date(+matched[1]);
            return;
        }

        configFromISO(config);
        if (config._isValid === false) {
            delete config._isValid;
        } else {
            return;
        }

        configFromRFC2822(config);
        if (config._isValid === false) {
            delete config._isValid;
        } else {
            return;
        }

        // Final attempt, use Input Fallback
        hooks.createFromInputFallback(config);
    }

    hooks.createFromInputFallback = deprecate(
        'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
        'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
        'discouraged and will be removed in an upcoming major release. Please refer to ' +
        'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
        function (config) {
            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
        }
    );

    // constant that refers to the ISO standard
    hooks.ISO_8601 = function () {};

    // constant that refers to the RFC 2822 form
    hooks.RFC_2822 = function () {};

    // date from string and format string
    function configFromStringAndFormat(config) {
        // TODO: Move this to another part of the creation flow to prevent circular deps
        if (config._f === hooks.ISO_8601) {
            configFromISO(config);
            return;
        }
        if (config._f === hooks.RFC_2822) {
            configFromRFC2822(config);
            return;
        }
        config._a = [];
        getParsingFlags(config).empty = true;

        // This array is used to make a Date, either with `new Date` or `Date.UTC`
        var string = '' + config._i,
            i, parsedInput, tokens, token, skipped,
            stringLength = string.length,
            totalParsedInputLength = 0;

        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];

        for (i = 0; i < tokens.length; i++) {
            token = tokens[i];
            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
            // console.log('token', token, 'parsedInput', parsedInput,
            //         'regex', getParseRegexForToken(token, config));
            if (parsedInput) {
                skipped = string.substr(0, string.indexOf(parsedInput));
                if (skipped.length > 0) {
                    getParsingFlags(config).unusedInput.push(skipped);
                }
                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
                totalParsedInputLength += parsedInput.length;
            }
            // don't parse if it's not a known token
            if (formatTokenFunctions[token]) {
                if (parsedInput) {
                    getParsingFlags(config).empty = false;
                } else {
                    getParsingFlags(config).unusedTokens.push(token);
                }
                addTimeToArrayFromToken(token, parsedInput, config);
            } else if (config._strict && !parsedInput) {
                getParsingFlags(config).unusedTokens.push(token);
            }
        }

        // add remaining unparsed input length to the string
        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
        if (string.length > 0) {
            getParsingFlags(config).unusedInput.push(string);
        }

        // clear _12h flag if hour is <= 12
        if (config._a[HOUR] <= 12 &&
            getParsingFlags(config).bigHour === true &&
            config._a[HOUR] > 0) {
            getParsingFlags(config).bigHour = undefined;
        }

        getParsingFlags(config).parsedDateParts = config._a.slice(0);
        getParsingFlags(config).meridiem = config._meridiem;
        // handle meridiem
        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);

        configFromArray(config);
        checkOverflow(config);
    }


    function meridiemFixWrap(locale, hour, meridiem) {
        var isPm;

        if (meridiem == null) {
            // nothing to do
            return hour;
        }
        if (locale.meridiemHour != null) {
            return locale.meridiemHour(hour, meridiem);
        } else if (locale.isPM != null) {
            // Fallback
            isPm = locale.isPM(meridiem);
            if (isPm && hour < 12) {
                hour += 12;
            }
            if (!isPm && hour === 12) {
                hour = 0;
            }
            return hour;
        } else {
            // this is not supposed to happen
            return hour;
        }
    }

    // date from string and array of format strings
    function configFromStringAndArray(config) {
        var tempConfig,
            bestMoment,

            scoreToBeat,
            i,
            currentScore;

        if (config._f.length === 0) {
            getParsingFlags(config).invalidFormat = true;
            config._d = new Date(NaN);
            return;
        }

        for (i = 0; i < config._f.length; i++) {
            currentScore = 0;
            tempConfig = copyConfig({}, config);
            if (config._useUTC != null) {
                tempConfig._useUTC = config._useUTC;
            }
            tempConfig._f = config._f[i];
            configFromStringAndFormat(tempConfig);

            if (!isValid(tempConfig)) {
                continue;
            }

            // if there is any input that was not parsed add a penalty for that format
            currentScore += getParsingFlags(tempConfig).charsLeftOver;

            //or tokens
            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;

            getParsingFlags(tempConfig).score = currentScore;

            if (scoreToBeat == null || currentScore < scoreToBeat) {
                scoreToBeat = currentScore;
                bestMoment = tempConfig;
            }
        }

        extend(config, bestMoment || tempConfig);
    }

    function configFromObject(config) {
        if (config._d) {
            return;
        }

        var i = normalizeObjectUnits(config._i);
        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond],
            function (obj) {
                return obj && parseInt(obj, 10);
            });

        configFromArray(config);
    }

    function createFromConfig(config) {
        var res = new Moment(checkOverflow(prepareConfig(config)));
        if (res._nextDay) {
            // Adding is smart enough around DST
            res.add(1, 'd');
            res._nextDay = undefined;
        }

        return res;
    }

    function prepareConfig(config) {
        var input = config._i,
            format = config._f;

        config._locale = config._locale || getLocale(config._l);

        if (input === null || (format === undefined && input === '')) {
            return createInvalid({
                nullInput: true
            });
        }

        if (typeof input === 'string') {
            config._i = input = config._locale.preparse(input);
        }

        if (isMoment(input)) {
            return new Moment(checkOverflow(input));
        } else if (isDate(input)) {
            config._d = input;
        } else if (isArray(format)) {
            configFromStringAndArray(config);
        } else if (format) {
            configFromStringAndFormat(config);
        } else {
            configFromInput(config);
        }

        if (!isValid(config)) {
            config._d = null;
        }

        return config;
    }

    function configFromInput(config) {
        var input = config._i;
        if (isUndefined(input)) {
            config._d = new Date(hooks.now());
        } else if (isDate(input)) {
            config._d = new Date(input.valueOf());
        } else if (typeof input === 'string') {
            configFromString(config);
        } else if (isArray(input)) {
            config._a = map(input.slice(0), function (obj) {
                return parseInt(obj, 10);
            });
            configFromArray(config);
        } else if (isObject(input)) {
            configFromObject(config);
        } else if (isNumber(input)) {
            // from milliseconds
            config._d = new Date(input);
        } else {
            hooks.createFromInputFallback(config);
        }
    }

    function createLocalOrUTC(input, format, locale, strict, isUTC) {
        var c = {};

        if (locale === true || locale === false) {
            strict = locale;
            locale = undefined;
        }

        if ((isObject(input) && isObjectEmpty(input)) ||
            (isArray(input) && input.length === 0)) {
            input = undefined;
        }
        // object construction must be done this way.
        // https://github.com/moment/moment/issues/1423
        c._isAMomentObject = true;
        c._useUTC = c._isUTC = isUTC;
        c._l = locale;
        c._i = input;
        c._f = format;
        c._strict = strict;

        return createFromConfig(c);
    }

    function createLocal(input, format, locale, strict) {
        return createLocalOrUTC(input, format, locale, strict, false);
    }

    var prototypeMin = deprecate(
        'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
        function () {
            var other = createLocal.apply(null, arguments);
            if (this.isValid() && other.isValid()) {
                return other < this ? this : other;
            } else {
                return createInvalid();
            }
        }
    );

    var prototypeMax = deprecate(
        'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
        function () {
            var other = createLocal.apply(null, arguments);
            if (this.isValid() && other.isValid()) {
                return other > this ? this : other;
            } else {
                return createInvalid();
            }
        }
    );

    // Pick a moment m from moments so that m[fn](other) is true for all
    // other. This relies on the function fn to be transitive.
    //
    // moments should either be an array of moment objects or an array, whose
    // first element is an array of moment objects.
    function pickBy(fn, moments) {
        var res, i;
        if (moments.length === 1 && isArray(moments[0])) {
            moments = moments[0];
        }
        if (!moments.length) {
            return createLocal();
        }
        res = moments[0];
        for (i = 1; i < moments.length; ++i) {
            if (!moments[i].isValid() || moments[i][fn](res)) {
                res = moments[i];
            }
        }
        return res;
    }

    // TODO: Use [].sort instead?
    function min() {
        var args = [].slice.call(arguments, 0);

        return pickBy('isBefore', args);
    }

    function max() {
        var args = [].slice.call(arguments, 0);

        return pickBy('isAfter', args);
    }

    var now = function () {
        return Date.now ? Date.now() : +(new Date());
    };

    var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];

    function isDurationValid(m) {
        for (var key in m) {
            if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
                return false;
            }
        }

        var unitHasDecimal = false;
        for (var i = 0; i < ordering.length; ++i) {
            if (m[ordering[i]]) {
                if (unitHasDecimal) {
                    return false; // only allow non-integers for smallest unit
                }
                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
                    unitHasDecimal = true;
                }
            }
        }

        return true;
    }

    function isValid$1() {
        return this._isValid;
    }

    function createInvalid$1() {
        return createDuration(NaN);
    }

    function Duration(duration) {
        var normalizedInput = normalizeObjectUnits(duration),
            years = normalizedInput.year || 0,
            quarters = normalizedInput.quarter || 0,
            months = normalizedInput.month || 0,
            weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
            days = normalizedInput.day || 0,
            hours = normalizedInput.hour || 0,
            minutes = normalizedInput.minute || 0,
            seconds = normalizedInput.second || 0,
            milliseconds = normalizedInput.millisecond || 0;

        this._isValid = isDurationValid(normalizedInput);

        // representation for dateAddRemove
        this._milliseconds = +milliseconds +
            seconds * 1e3 + // 1000
            minutes * 6e4 + // 1000 * 60
            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
        // Because of dateAddRemove treats 24 hours as different from a
        // day when working around DST, we need to store them separately
        this._days = +days +
            weeks * 7;
        // It is impossible to translate months into days without knowing
        // which months you are are talking about, so we have to store
        // it separately.
        this._months = +months +
            quarters * 3 +
            years * 12;

        this._data = {};

        this._locale = getLocale();

        this._bubble();
    }

    function isDuration(obj) {
        return obj instanceof Duration;
    }

    function absRound(number) {
        if (number < 0) {
            return Math.round(-1 * number) * -1;
        } else {
            return Math.round(number);
        }
    }

    // FORMATTING

    function offset(token, separator) {
        addFormatToken(token, 0, 0, function () {
            var offset = this.utcOffset();
            var sign = '+';
            if (offset < 0) {
                offset = -offset;
                sign = '-';
            }
            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
        });
    }

    offset('Z', ':');
    offset('ZZ', '');

    // PARSING

    addRegexToken('Z', matchShortOffset);
    addRegexToken('ZZ', matchShortOffset);
    addParseToken(['Z', 'ZZ'], function (input, array, config) {
        config._useUTC = true;
        config._tzm = offsetFromString(matchShortOffset, input);
    });

    // HELPERS

    // timezone chunker
    // '+10:00' > ['10',  '00']
    // '-1530'  > ['-15', '30']
    var chunkOffset = /([\+\-]|\d\d)/gi;

    function offsetFromString(matcher, string) {
        var matches = (string || '').match(matcher);

        if (matches === null) {
            return null;
        }

        var chunk = matches[matches.length - 1] || [];
        var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
        var minutes = +(parts[1] * 60) + toInt(parts[2]);

        return minutes === 0 ?
            0 :
            parts[0] === '+' ? minutes : -minutes;
    }

    // Return a moment from input, that is local/utc/zone equivalent to model.
    function cloneWithOffset(input, model) {
        var res, diff;
        if (model._isUTC) {
            res = model.clone();
            diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) -
                res.valueOf();
            // Use low-level api, because this fn is low-level api.
            res._d.setTime(res._d.valueOf() + diff);
            hooks.updateOffset(res, false);
            return res;
        } else {
            return createLocal(input).local();
        }
    }

    function getDateOffset(m) {
        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
        // https://github.com/moment/moment/pull/1871
        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
    }

    // HOOKS

    // This function will be called whenever a moment is mutated.
    // It is intended to keep the offset in sync with the timezone.
    hooks.updateOffset = function () {};

    // MOMENTS

    // keepLocalTime = true means only change the timezone, without
    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
    // +0200, so we adjust the time as needed, to be valid.
    //
    // Keeping the time actually adds/subtracts (one hour)
    // from the actual represented time. That is why we call updateOffset
    // a second time. In case it wants us to change the offset again
    // _changeInProgress == true case, then we have to adjust, because
    // there is no such time in the given timezone.
    function getSetOffset(input, keepLocalTime, keepMinutes) {
        var offset = this._offset || 0,
            localAdjust;
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }
        if (input != null) {
            if (typeof input === 'string') {
                input = offsetFromString(matchShortOffset, input);
                if (input === null) {
                    return this;
                }
            } else if (Math.abs(input) < 16 && !keepMinutes) {
                input = input * 60;
            }
            if (!this._isUTC && keepLocalTime) {
                localAdjust = getDateOffset(this);
            }
            this._offset = input;
            this._isUTC = true;
            if (localAdjust != null) {
                this.add(localAdjust, 'm');
            }
            if (offset !== input) {
                if (!keepLocalTime || this._changeInProgress) {
                    addSubtract(this, createDuration(input - offset, 'm'), 1, false);
                } else if (!this._changeInProgress) {
                    this._changeInProgress = true;
                    hooks.updateOffset(this, true);
                    this._changeInProgress = null;
                }
            }
            return this;
        } else {
            return this._isUTC ? offset : getDateOffset(this);
        }
    }

    function getSetZone(input, keepLocalTime) {
        if (input != null) {
            if (typeof input !== 'string') {
                input = -input;
            }

            this.utcOffset(input, keepLocalTime);

            return this;
        } else {
            return -this.utcOffset();
        }
    }

    function setOffsetToUTC(keepLocalTime) {
        return this.utcOffset(0, keepLocalTime);
    }

    function setOffsetToLocal(keepLocalTime) {
        if (this._isUTC) {
            this.utcOffset(0, keepLocalTime);
            this._isUTC = false;

            if (keepLocalTime) {
                this.subtract(getDateOffset(this), 'm');
            }
        }
        return this;
    }

    function setOffsetToParsedOffset() {
        if (this._tzm != null) {
            this.utcOffset(this._tzm, false, true);
        } else if (typeof this._i === 'string') {
            var tZone = offsetFromString(matchOffset, this._i);
            if (tZone != null) {
                this.utcOffset(tZone);
            } else {
                this.utcOffset(0, true);
            }
        }
        return this;
    }

    function hasAlignedHourOffset(input) {
        if (!this.isValid()) {
            return false;
        }
        input = input ? createLocal(input).utcOffset() : 0;

        return (this.utcOffset() - input) % 60 === 0;
    }

    function isDaylightSavingTime() {
        return (
            this.utcOffset() > this.clone().month(0).utcOffset() ||
            this.utcOffset() > this.clone().month(5).utcOffset()
        );
    }

    function isDaylightSavingTimeShifted() {
        if (!isUndefined(this._isDSTShifted)) {
            return this._isDSTShifted;
        }

        var c = {};

        copyConfig(c, this);
        c = prepareConfig(c);

        if (c._a) {
            var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
            this._isDSTShifted = this.isValid() &&
                compareArrays(c._a, other.toArray()) > 0;
        } else {
            this._isDSTShifted = false;
        }

        return this._isDSTShifted;
    }

    function isLocal() {
        return this.isValid() ? !this._isUTC : false;
    }

    function isUtcOffset() {
        return this.isValid() ? this._isUTC : false;
    }

    function isUtc() {
        return this.isValid() ? this._isUTC && this._offset === 0 : false;
    }

    // ASP.NET json date format regex
    var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;

    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
    // and further modified to allow for strings containing both week and day
    var isoRegex =
        /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;

    function createDuration(input, key) {
        var duration = input,
            // matching against regexp is expensive, do it on demand
            match = null,
            sign,
            ret,
            diffRes;

        if (isDuration(input)) {
            duration = {
                ms: input._milliseconds,
                d: input._days,
                M: input._months
            };
        } else if (isNumber(input)) {
            duration = {};
            if (key) {
                duration[key] = input;
            } else {
                duration.milliseconds = input;
            }
        } else if (!!(match = aspNetRegex.exec(input))) {
            sign = (match[1] === '-') ? -1 : 1;
            duration = {
                y: 0,
                d: toInt(match[DATE]) * sign,
                h: toInt(match[HOUR]) * sign,
                m: toInt(match[MINUTE]) * sign,
                s: toInt(match[SECOND]) * sign,
                ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
            };
        } else if (!!(match = isoRegex.exec(input))) {
            sign = (match[1] === '-') ? -1 : 1;
            duration = {
                y: parseIso(match[2], sign),
                M: parseIso(match[3], sign),
                w: parseIso(match[4], sign),
                d: parseIso(match[5], sign),
                h: parseIso(match[6], sign),
                m: parseIso(match[7], sign),
                s: parseIso(match[8], sign)
            };
        } else if (duration == null) { // checks for null or undefined
            duration = {};
        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
            diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));

            duration = {};
            duration.ms = diffRes.milliseconds;
            duration.M = diffRes.months;
        }

        ret = new Duration(duration);

        if (isDuration(input) && hasOwnProp(input, '_locale')) {
            ret._locale = input._locale;
        }

        return ret;
    }

    createDuration.fn = Duration.prototype;
    createDuration.invalid = createInvalid$1;

    function parseIso(inp, sign) {
        // We'd normally use ~~inp for this, but unfortunately it also
        // converts floats to ints.
        // inp may be undefined, so careful calling replace on it.
        var res = inp && parseFloat(inp.replace(',', '.'));
        // apply sign while we're at it
        return (isNaN(res) ? 0 : res) * sign;
    }

    function positiveMomentsDifference(base, other) {
        var res = {};

        res.months = other.month() - base.month() +
            (other.year() - base.year()) * 12;
        if (base.clone().add(res.months, 'M').isAfter(other)) {
            --res.months;
        }

        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));

        return res;
    }

    function momentsDifference(base, other) {
        var res;
        if (!(base.isValid() && other.isValid())) {
            return {
                milliseconds: 0,
                months: 0
            };
        }

        other = cloneWithOffset(other, base);
        if (base.isBefore(other)) {
            res = positiveMomentsDifference(base, other);
        } else {
            res = positiveMomentsDifference(other, base);
            res.milliseconds = -res.milliseconds;
            res.months = -res.months;
        }

        return res;
    }

    // TODO: remove 'name' arg after deprecation is removed
    function createAdder(direction, name) {
        return function (val, period) {
            var dur, tmp;
            //invert the arguments, but complain about it
            if (period !== null && !isNaN(+period)) {
                deprecateSimple(name, 'moment().' + name +
                    '(period, number) is deprecated. Please use moment().' + name +
                    '(number, period). ' +
                    'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
                tmp = val;
                val = period;
                period = tmp;
            }

            val = typeof val === 'string' ? +val : val;
            dur = createDuration(val, period);
            addSubtract(this, dur, direction);
            return this;
        };
    }

    function addSubtract(mom, duration, isAdding, updateOffset) {
        var milliseconds = duration._milliseconds,
            days = absRound(duration._days),
            months = absRound(duration._months);

        if (!mom.isValid()) {
            // No op
            return;
        }

        updateOffset = updateOffset == null ? true : updateOffset;

        if (months) {
            setMonth(mom, get(mom, 'Month') + months * isAdding);
        }
        if (days) {
            set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
        }
        if (milliseconds) {
            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
        }
        if (updateOffset) {
            hooks.updateOffset(mom, days || months);
        }
    }

    var add = createAdder(1, 'add');
    var subtract = createAdder(-1, 'subtract');

    function getCalendarFormat(myMoment, now) {
        var diff = myMoment.diff(now, 'days', true);
        return diff < -6 ? 'sameElse' :
            diff < -1 ? 'lastWeek' :
                diff < 0 ? 'lastDay' :
                    diff < 1 ? 'sameDay' :
                        diff < 2 ? 'nextDay' :
                            diff < 7 ? 'nextWeek' : 'sameElse';
    }

    function calendar$1(time, formats) {
        // We want to compare the start of today, vs this.
        // Getting start-of-today depends on whether we're local/utc/offset or not.
        var now = time || createLocal(),
            sod = cloneWithOffset(now, this).startOf('day'),
            format = hooks.calendarFormat(this, sod) || 'sameElse';

        var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[
            format]);

        return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
    }

    function clone() {
        return new Moment(this);
    }

    function isAfter(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
            return false;
        }
        units = normalizeUnits(units) || 'millisecond';
        if (units === 'millisecond') {
            return this.valueOf() > localInput.valueOf();
        } else {
            return localInput.valueOf() < this.clone().startOf(units).valueOf();
        }
    }

    function isBefore(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
            return false;
        }
        units = normalizeUnits(units) || 'millisecond';
        if (units === 'millisecond') {
            return this.valueOf() < localInput.valueOf();
        } else {
            return this.clone().endOf(units).valueOf() < localInput.valueOf();
        }
    }

    function isBetween(from, to, units, inclusivity) {
        var localFrom = isMoment(from) ? from : createLocal(from),
            localTo = isMoment(to) ? to : createLocal(to);
        if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
            return false;
        }
        inclusivity = inclusivity || '()';
        return (inclusivity[0] === '(' ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) &&
            (inclusivity[1] === ')' ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
    }

    function isSame(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input),
            inputMs;
        if (!(this.isValid() && localInput.isValid())) {
            return false;
        }
        units = normalizeUnits(units) || 'millisecond';
        if (units === 'millisecond') {
            return this.valueOf() === localInput.valueOf();
        } else {
            inputMs = localInput.valueOf();
            return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units)
                .valueOf();
        }
    }

    function isSameOrAfter(input, units) {
        return this.isSame(input, units) || this.isAfter(input, units);
    }

    function isSameOrBefore(input, units) {
        return this.isSame(input, units) || this.isBefore(input, units);
    }

    function diff(input, units, asFloat) {
        var that,
            zoneDelta,
            output;

        if (!this.isValid()) {
            return NaN;
        }

        that = cloneWithOffset(input, this);

        if (!that.isValid()) {
            return NaN;
        }

        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;

        units = normalizeUnits(units);

        switch (units) {
            case 'year':
                output = monthDiff(this, that) / 12;
                break;
            case 'month':
                output = monthDiff(this, that);
                break;
            case 'quarter':
                output = monthDiff(this, that) / 3;
                break;
            case 'second':
                output = (this - that) / 1e3;
                break; // 1000
            case 'minute':
                output = (this - that) / 6e4;
                break; // 1000 * 60
            case 'hour':
                output = (this - that) / 36e5;
                break; // 1000 * 60 * 60
            case 'day':
                output = (this - that - zoneDelta) / 864e5;
                break; // 1000 * 60 * 60 * 24, negate dst
            case 'week':
                output = (this - that - zoneDelta) / 6048e5;
                break; // 1000 * 60 * 60 * 24 * 7, negate dst
            default:
                output = this - that;
        }

        return asFloat ? output : absFloor(output);
    }

    function monthDiff(a, b) {
        // difference in months
        var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
            // b is in (anchor - 1 month, anchor + 1 month)
            anchor = a.clone().add(wholeMonthDiff, 'months'),
            anchor2, adjust;

        if (b - anchor < 0) {
            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
            // linear across the month
            adjust = (b - anchor) / (anchor - anchor2);
        } else {
            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
            // linear across the month
            adjust = (b - anchor) / (anchor2 - anchor);
        }

        //check for negative zero, return zero if negative zero
        return -(wholeMonthDiff + adjust) || 0;
    }

    hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
    hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';

    function toString() {
        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
    }

    function toISOString(keepOffset) {
        if (!this.isValid()) {
            return null;
        }
        var utc = keepOffset !== true;
        var m = utc ? this.clone().utc() : this;
        if (m.year() < 0 || m.year() > 9999) {
            return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
        }
        if (isFunction(Date.prototype.toISOString)) {
            // native implementation is ~50x faster, use it when we can
            if (utc) {
                return this.toDate().toISOString();
            } else {
                return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z',
                    formatMoment(m, 'Z'));
            }
        }
        return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
    }

    /**
     * Return a human readable representation of a moment that can
     * also be evaluated to get a new moment which is the same
     *
     * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
     */
    function inspect() {
        if (!this.isValid()) {
            return 'moment.invalid(/* ' + this._i + ' */)';
        }
        var func = 'moment';
        var zone = '';
        if (!this.isLocal()) {
            func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
            zone = 'Z';
        }
        var prefix = '[' + func + '("]';
        var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
        var datetime = '-MM-DD[T]HH:mm:ss.SSS';
        var suffix = zone + '[")]';

        return this.format(prefix + year + datetime + suffix);
    }

    function format(inputString) {
        if (!inputString) {
            inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
        }
        var output = formatMoment(this, inputString);
        return this.localeData().postformat(output);
    }

    function from(time, withoutSuffix) {
        if (this.isValid() &&
            ((isMoment(time) && time.isValid()) ||
                createLocal(time).isValid())) {
            return createDuration({
                to: this,
                from: time
            }).locale(this.locale()).humanize(!withoutSuffix);
        } else {
            return this.localeData().invalidDate();
        }
    }

    function fromNow(withoutSuffix) {
        return this.from(createLocal(), withoutSuffix);
    }

    function to(time, withoutSuffix) {
        if (this.isValid() &&
            ((isMoment(time) && time.isValid()) ||
                createLocal(time).isValid())) {
            return createDuration({
                from: this,
                to: time
            }).locale(this.locale()).humanize(!withoutSuffix);
        } else {
            return this.localeData().invalidDate();
        }
    }

    function toNow(withoutSuffix) {
        return this.to(createLocal(), withoutSuffix);
    }

    // If passed a locale key, it will set the locale for this
    // instance.  Otherwise, it will return the locale configuration
    // variables for this instance.
    function locale(key) {
        var newLocaleData;

        if (key === undefined) {
            return this._locale._abbr;
        } else {
            newLocaleData = getLocale(key);
            if (newLocaleData != null) {
                this._locale = newLocaleData;
            }
            return this;
        }
    }

    var lang = deprecate(
        'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
        function (key) {
            if (key === undefined) {
                return this.localeData();
            } else {
                return this.locale(key);
            }
        }
    );

    function localeData() {
        return this._locale;
    }

    var MS_PER_SECOND = 1000;
    var MS_PER_MINUTE = 60 * MS_PER_SECOND;
    var MS_PER_HOUR = 60 * MS_PER_MINUTE;
    var MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;

    // actual modulo - handles negative numbers (for dates before 1970):
    function mod$1(dividend, divisor) {
        return (dividend % divisor + divisor) % divisor;
    }

    function localStartOfDate(y, m, d) {
        // the date constructor remaps years 0-99 to 1900-1999
        if (y < 100 && y >= 0) {
            // preserve leap years using a full 400 year cycle, then reset
            return new Date(y + 400, m, d) - MS_PER_400_YEARS;
        } else {
            return new Date(y, m, d).valueOf();
        }
    }

    function utcStartOfDate(y, m, d) {
        // Date.UTC remaps years 0-99 to 1900-1999
        if (y < 100 && y >= 0) {
            // preserve leap years using a full 400 year cycle, then reset
            return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
        } else {
            return Date.UTC(y, m, d);
        }
    }

    function startOf(units) {
        var time;
        units = normalizeUnits(units);
        if (units === undefined || units === 'millisecond' || !this.isValid()) {
            return this;
        }

        var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;

        switch (units) {
            case 'year':
                time = startOfDate(this.year(), 0, 1);
                break;
            case 'quarter':
                time = startOfDate(this.year(), this.month() - this.month() % 3, 1);
                break;
            case 'month':
                time = startOfDate(this.year(), this.month(), 1);
                break;
            case 'week':
                time = startOfDate(this.year(), this.month(), this.date() - this.weekday());
                break;
            case 'isoWeek':
                time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1));
                break;
            case 'day':
            case 'date':
                time = startOfDate(this.year(), this.month(), this.date());
                break;
            case 'hour':
                time = this._d.valueOf();
                time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);
                break;
            case 'minute':
                time = this._d.valueOf();
                time -= mod$1(time, MS_PER_MINUTE);
                break;
            case 'second':
                time = this._d.valueOf();
                time -= mod$1(time, MS_PER_SECOND);
                break;
        }

        this._d.setTime(time);
        hooks.updateOffset(this, true);
        return this;
    }

    function endOf(units) {
        var time;
        units = normalizeUnits(units);
        if (units === undefined || units === 'millisecond' || !this.isValid()) {
            return this;
        }

        var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;

        switch (units) {
            case 'year':
                time = startOfDate(this.year() + 1, 0, 1) - 1;
                break;
            case 'quarter':
                time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1;
                break;
            case 'month':
                time = startOfDate(this.year(), this.month() + 1, 1) - 1;
                break;
            case 'week':
                time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1;
                break;
            case 'isoWeek':
                time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) -
                    1;
                break;
            case 'day':
            case 'date':
                time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
                break;
            case 'hour':
                time = this._d.valueOf();
                time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
                    MS_PER_HOUR) - 1;
                break;
            case 'minute':
                time = this._d.valueOf();
                time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
                break;
            case 'second':
                time = this._d.valueOf();
                time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
                break;
        }

        this._d.setTime(time);
        hooks.updateOffset(this, true);
        return this;
    }

    function valueOf() {
        return this._d.valueOf() - ((this._offset || 0) * 60000);
    }

    function unix() {
        return Math.floor(this.valueOf() / 1000);
    }

    function toDate() {
        return new Date(this.valueOf());
    }

    function toArray() {
        var m = this;
        return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
    }

    function toObject() {
        var m = this;
        return {
            years: m.year(),
            months: m.month(),
            date: m.date(),
            hours: m.hours(),
            minutes: m.minutes(),
            seconds: m.seconds(),
            milliseconds: m.milliseconds()
        };
    }

    function toJSON() {
        // new Date(NaN).toJSON() === null
        return this.isValid() ? this.toISOString() : null;
    }

    function isValid$2() {
        return isValid(this);
    }

    function parsingFlags() {
        return extend({}, getParsingFlags(this));
    }

    function invalidAt() {
        return getParsingFlags(this).overflow;
    }

    function creationData() {
        return {
            input: this._i,
            format: this._f,
            locale: this._locale,
            isUTC: this._isUTC,
            strict: this._strict
        };
    }

    // FORMATTING

    addFormatToken(0, ['gg', 2], 0, function () {
        return this.weekYear() % 100;
    });

    addFormatToken(0, ['GG', 2], 0, function () {
        return this.isoWeekYear() % 100;
    });

    function addWeekYearFormatToken(token, getter) {
        addFormatToken(0, [token, token.length], 0, getter);
    }

    addWeekYearFormatToken('gggg', 'weekYear');
    addWeekYearFormatToken('ggggg', 'weekYear');
    addWeekYearFormatToken('GGGG', 'isoWeekYear');
    addWeekYearFormatToken('GGGGG', 'isoWeekYear');

    // ALIASES

    addUnitAlias('weekYear', 'gg');
    addUnitAlias('isoWeekYear', 'GG');

    // PRIORITY

    addUnitPriority('weekYear', 1);
    addUnitPriority('isoWeekYear', 1);


    // PARSING

    addRegexToken('G', matchSigned);
    addRegexToken('g', matchSigned);
    addRegexToken('GG', match1to2, match2);
    addRegexToken('gg', match1to2, match2);
    addRegexToken('GGGG', match1to4, match4);
    addRegexToken('gggg', match1to4, match4);
    addRegexToken('GGGGG', match1to6, match6);
    addRegexToken('ggggg', match1to6, match6);

    addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
        week[token.substr(0, 2)] = toInt(input);
    });

    addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
        week[token] = hooks.parseTwoDigitYear(input);
    });

    // MOMENTS

    function getSetWeekYear(input) {
        return getSetWeekYearHelper.call(this,
            input,
            this.week(),
            this.weekday(),
            this.localeData()._week.dow,
            this.localeData()._week.doy);
    }

    function getSetISOWeekYear(input) {
        return getSetWeekYearHelper.call(this,
            input, this.isoWeek(), this.isoWeekday(), 1, 4);
    }

    function getISOWeeksInYear() {
        return weeksInYear(this.year(), 1, 4);
    }

    function getWeeksInYear() {
        var weekInfo = this.localeData()._week;
        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
    }

    function getSetWeekYearHelper(input, week, weekday, dow, doy) {
        var weeksTarget;
        if (input == null) {
            return weekOfYear(this, dow, doy).year;
        } else {
            weeksTarget = weeksInYear(input, dow, doy);
            if (week > weeksTarget) {
                week = weeksTarget;
            }
            return setWeekAll.call(this, input, week, weekday, dow, doy);
        }
    }

    function setWeekAll(weekYear, week, weekday, dow, doy) {
        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
            date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);

        this.year(date.getUTCFullYear());
        this.month(date.getUTCMonth());
        this.date(date.getUTCDate());
        return this;
    }

    // FORMATTING

    addFormatToken('Q', 0, 'Qo', 'quarter');

    // ALIASES

    addUnitAlias('quarter', 'Q');

    // PRIORITY

    addUnitPriority('quarter', 7);

    // PARSING

    addRegexToken('Q', match1);
    addParseToken('Q', function (input, array) {
        array[MONTH] = (toInt(input) - 1) * 3;
    });

    // MOMENTS

    function getSetQuarter(input) {
        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() %
            3);
    }

    // FORMATTING

    addFormatToken('D', ['DD', 2], 'Do', 'date');

    // ALIASES

    addUnitAlias('date', 'D');

    // PRIORITY
    addUnitPriority('date', 9);

    // PARSING

    addRegexToken('D', match1to2);
    addRegexToken('DD', match1to2, match2);
    addRegexToken('Do', function (isStrict, locale) {
        // TODO: Remove "ordinalParse" fallback in next major release.
        return isStrict ?
            (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
            locale._dayOfMonthOrdinalParseLenient;
    });

    addParseToken(['D', 'DD'], DATE);
    addParseToken('Do', function (input, array) {
        array[DATE] = toInt(input.match(match1to2)[0]);
    });

    // MOMENTS

    var getSetDayOfMonth = makeGetSet('Date', true);

    // FORMATTING

    addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');

    // ALIASES

    addUnitAlias('dayOfYear', 'DDD');

    // PRIORITY
    addUnitPriority('dayOfYear', 4);

    // PARSING

    addRegexToken('DDD', match1to3);
    addRegexToken('DDDD', match3);
    addParseToken(['DDD', 'DDDD'], function (input, array, config) {
        config._dayOfYear = toInt(input);
    });

    // HELPERS

    // MOMENTS

    function getSetDayOfYear(input) {
        var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) +
            1;
        return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
    }

    // FORMATTING

    addFormatToken('m', ['mm', 2], 0, 'minute');

    // ALIASES

    addUnitAlias('minute', 'm');

    // PRIORITY

    addUnitPriority('minute', 14);

    // PARSING

    addRegexToken('m', match1to2);
    addRegexToken('mm', match1to2, match2);
    addParseToken(['m', 'mm'], MINUTE);

    // MOMENTS

    var getSetMinute = makeGetSet('Minutes', false);

    // FORMATTING

    addFormatToken('s', ['ss', 2], 0, 'second');

    // ALIASES

    addUnitAlias('second', 's');

    // PRIORITY

    addUnitPriority('second', 15);

    // PARSING

    addRegexToken('s', match1to2);
    addRegexToken('ss', match1to2, match2);
    addParseToken(['s', 'ss'], SECOND);

    // MOMENTS

    var getSetSecond = makeGetSet('Seconds', false);

    // FORMATTING

    addFormatToken('S', 0, 0, function () {
        return ~~(this.millisecond() / 100);
    });

    addFormatToken(0, ['SS', 2], 0, function () {
        return ~~(this.millisecond() / 10);
    });

    addFormatToken(0, ['SSS', 3], 0, 'millisecond');
    addFormatToken(0, ['SSSS', 4], 0, function () {
        return this.millisecond() * 10;
    });
    addFormatToken(0, ['SSSSS', 5], 0, function () {
        return this.millisecond() * 100;
    });
    addFormatToken(0, ['SSSSSS', 6], 0, function () {
        return this.millisecond() * 1000;
    });
    addFormatToken(0, ['SSSSSSS', 7], 0, function () {
        return this.millisecond() * 10000;
    });
    addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
        return this.millisecond() * 100000;
    });
    addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
        return this.millisecond() * 1000000;
    });


    // ALIASES

    addUnitAlias('millisecond', 'ms');

    // PRIORITY

    addUnitPriority('millisecond', 16);

    // PARSING

    addRegexToken('S', match1to3, match1);
    addRegexToken('SS', match1to3, match2);
    addRegexToken('SSS', match1to3, match3);

    var token;
    for (token = 'SSSS'; token.length <= 9; token += 'S') {
        addRegexToken(token, matchUnsigned);
    }

    function parseMs(input, array) {
        array[MILLISECOND] = toInt(('0.' + input) * 1000);
    }

    for (token = 'S'; token.length <= 9; token += 'S') {
        addParseToken(token, parseMs);
    }
    // MOMENTS

    var getSetMillisecond = makeGetSet('Milliseconds', false);

    // FORMATTING

    addFormatToken('z', 0, 0, 'zoneAbbr');
    addFormatToken('zz', 0, 0, 'zoneName');

    // MOMENTS

    function getZoneAbbr() {
        return this._isUTC ? 'UTC' : '';
    }

    function getZoneName() {
        return this._isUTC ? 'Coordinated Universal Time' : '';
    }

    var proto = Moment.prototype;

    proto.add = add;
    proto.calendar = calendar$1;
    proto.clone = clone;
    proto.diff = diff;
    proto.endOf = endOf;
    proto.format = format;
    proto.from = from;
    proto.fromNow = fromNow;
    proto.to = to;
    proto.toNow = toNow;
    proto.get = stringGet;
    proto.invalidAt = invalidAt;
    proto.isAfter = isAfter;
    proto.isBefore = isBefore;
    proto.isBetween = isBetween;
    proto.isSame = isSame;
    proto.isSameOrAfter = isSameOrAfter;
    proto.isSameOrBefore = isSameOrBefore;
    proto.isValid = isValid$2;
    proto.lang = lang;
    proto.locale = locale;
    proto.localeData = localeData;
    proto.max = prototypeMax;
    proto.min = prototypeMin;
    proto.parsingFlags = parsingFlags;
    proto.set = stringSet;
    proto.startOf = startOf;
    proto.subtract = subtract;
    proto.toArray = toArray;
    proto.toObject = toObject;
    proto.toDate = toDate;
    proto.toISOString = toISOString;
    proto.inspect = inspect;
    proto.toJSON = toJSON;
    proto.toString = toString;
    proto.unix = unix;
    proto.valueOf = valueOf;
    proto.creationData = creationData;
    proto.year = getSetYear;
    proto.isLeapYear = getIsLeapYear;
    proto.weekYear = getSetWeekYear;
    proto.isoWeekYear = getSetISOWeekYear;
    proto.quarter = proto.quarters = getSetQuarter;
    proto.month = getSetMonth;
    proto.daysInMonth = getDaysInMonth;
    proto.week = proto.weeks = getSetWeek;
    proto.isoWeek = proto.isoWeeks = getSetISOWeek;
    proto.weeksInYear = getWeeksInYear;
    proto.isoWeeksInYear = getISOWeeksInYear;
    proto.date = getSetDayOfMonth;
    proto.day = proto.days = getSetDayOfWeek;
    proto.weekday = getSetLocaleDayOfWeek;
    proto.isoWeekday = getSetISODayOfWeek;
    proto.dayOfYear = getSetDayOfYear;
    proto.hour = proto.hours = getSetHour;
    proto.minute = proto.minutes = getSetMinute;
    proto.second = proto.seconds = getSetSecond;
    proto.millisecond = proto.milliseconds = getSetMillisecond;
    proto.utcOffset = getSetOffset;
    proto.utc = setOffsetToUTC;
    proto.local = setOffsetToLocal;
    proto.parseZone = setOffsetToParsedOffset;
    proto.hasAlignedHourOffset = hasAlignedHourOffset;
    proto.isDST = isDaylightSavingTime;
    proto.isLocal = isLocal;
    proto.isUtcOffset = isUtcOffset;
    proto.isUtc = isUtc;
    proto.isUTC = isUtc;
    proto.zoneAbbr = getZoneAbbr;
    proto.zoneName = getZoneName;
    proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
    proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
    proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
    proto.zone = deprecate(
        'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
        getSetZone);
    proto.isDSTShifted = deprecate(
        'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
        isDaylightSavingTimeShifted);

    function createUnix(input) {
        return createLocal(input * 1000);
    }

    function createInZone() {
        return createLocal.apply(null, arguments).parseZone();
    }

    function preParsePostFormat(string) {
        return string;
    }

    var proto$1 = Locale.prototype;

    proto$1.calendar = calendar;
    proto$1.longDateFormat = longDateFormat;
    proto$1.invalidDate = invalidDate;
    proto$1.ordinal = ordinal;
    proto$1.preparse = preParsePostFormat;
    proto$1.postformat = preParsePostFormat;
    proto$1.relativeTime = relativeTime;
    proto$1.pastFuture = pastFuture;
    proto$1.set = set;

    proto$1.months = localeMonths;
    proto$1.monthsShort = localeMonthsShort;
    proto$1.monthsParse = localeMonthsParse;
    proto$1.monthsRegex = monthsRegex;
    proto$1.monthsShortRegex = monthsShortRegex;
    proto$1.week = localeWeek;
    proto$1.firstDayOfYear = localeFirstDayOfYear;
    proto$1.firstDayOfWeek = localeFirstDayOfWeek;

    proto$1.weekdays = localeWeekdays;
    proto$1.weekdaysMin = localeWeekdaysMin;
    proto$1.weekdaysShort = localeWeekdaysShort;
    proto$1.weekdaysParse = localeWeekdaysParse;

    proto$1.weekdaysRegex = weekdaysRegex;
    proto$1.weekdaysShortRegex = weekdaysShortRegex;
    proto$1.weekdaysMinRegex = weekdaysMinRegex;

    proto$1.isPM = localeIsPM;
    proto$1.meridiem = localeMeridiem;

    function get$1(format, index, field, setter) {
        var locale = getLocale();
        var utc = createUTC().set(setter, index);
        return locale[field](utc, format);
    }

    function listMonthsImpl(format, index, field) {
        if (isNumber(format)) {
            index = format;
            format = undefined;
        }

        format = format || '';

        if (index != null) {
            return get$1(format, index, field, 'month');
        }

        var i;
        var out = [];
        for (i = 0; i < 12; i++) {
            out[i] = get$1(format, i, field, 'month');
        }
        return out;
    }

    // ()
    // (5)
    // (fmt, 5)
    // (fmt)
    // (true)
    // (true, 5)
    // (true, fmt, 5)
    // (true, fmt)
    function listWeekdaysImpl(localeSorted, format, index, field) {
        if (typeof localeSorted === 'boolean') {
            if (isNumber(format)) {
                index = format;
                format = undefined;
            }

            format = format || '';
        } else {
            format = localeSorted;
            index = format;
            localeSorted = false;

            if (isNumber(format)) {
                index = format;
                format = undefined;
            }

            format = format || '';
        }

        var locale = getLocale(),
            shift = localeSorted ? locale._week.dow : 0;

        if (index != null) {
            return get$1(format, (index + shift) % 7, field, 'day');
        }

        var i;
        var out = [];
        for (i = 0; i < 7; i++) {
            out[i] = get$1(format, (i + shift) % 7, field, 'day');
        }
        return out;
    }

    function listMonths(format, index) {
        return listMonthsImpl(format, index, 'months');
    }

    function listMonthsShort(format, index) {
        return listMonthsImpl(format, index, 'monthsShort');
    }

    function listWeekdays(localeSorted, format, index) {
        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
    }

    function listWeekdaysShort(localeSorted, format, index) {
        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
    }

    function listWeekdaysMin(localeSorted, format, index) {
        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
    }

    getSetGlobalLocale('en', {
        dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
        ordinal: function (number) {
            var b = number % 10,
                output = (toInt(number % 100 / 10) === 1) ? 'th' :
                    (b === 1) ? 'st' :
                        (b === 2) ? 'nd' :
                            (b === 3) ? 'rd' : 'th';
            return number + output;
        }
    });

    // Side effect imports

    hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
    hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);

    var mathAbs = Math.abs;

    function abs() {
        var data = this._data;

        this._milliseconds = mathAbs(this._milliseconds);
        this._days = mathAbs(this._days);
        this._months = mathAbs(this._months);

        data.milliseconds = mathAbs(data.milliseconds);
        data.seconds = mathAbs(data.seconds);
        data.minutes = mathAbs(data.minutes);
        data.hours = mathAbs(data.hours);
        data.months = mathAbs(data.months);
        data.years = mathAbs(data.years);

        return this;
    }

    function addSubtract$1(duration, input, value, direction) {
        var other = createDuration(input, value);

        duration._milliseconds += direction * other._milliseconds;
        duration._days += direction * other._days;
        duration._months += direction * other._months;

        return duration._bubble();
    }

    // supports only 2.0-style add(1, 's') or add(duration)
    function add$1(input, value) {
        return addSubtract$1(this, input, value, 1);
    }

    // supports only 2.0-style subtract(1, 's') or subtract(duration)
    function subtract$1(input, value) {
        return addSubtract$1(this, input, value, -1);
    }

    function absCeil(number) {
        if (number < 0) {
            return Math.floor(number);
        } else {
            return Math.ceil(number);
        }
    }

    function bubble() {
        var milliseconds = this._milliseconds;
        var days = this._days;
        var months = this._months;
        var data = this._data;
        var seconds, minutes, hours, years, monthsFromDays;

        // if we have a mix of positive and negative values, bubble down first
        // check: https://github.com/moment/moment/issues/2166
        if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
            (milliseconds <= 0 && days <= 0 && months <= 0))) {
            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
            days = 0;
            months = 0;
        }

        // The following code bubbles up values, see the tests for
        // examples of what that means.
        data.milliseconds = milliseconds % 1000;

        seconds = absFloor(milliseconds / 1000);
        data.seconds = seconds % 60;

        minutes = absFloor(seconds / 60);
        data.minutes = minutes % 60;

        hours = absFloor(minutes / 60);
        data.hours = hours % 24;

        days += absFloor(hours / 24);

        // convert days to months
        monthsFromDays = absFloor(daysToMonths(days));
        months += monthsFromDays;
        days -= absCeil(monthsToDays(monthsFromDays));

        // 12 months -> 1 year
        years = absFloor(months / 12);
        months %= 12;

        data.days = days;
        data.months = months;
        data.years = years;

        return this;
    }

    function daysToMonths(days) {
        // 400 years have 146097 days (taking into account leap year rules)
        // 400 years have 12 months === 4800
        return days * 4800 / 146097;
    }

    function monthsToDays(months) {
        // the reverse of daysToMonths
        return months * 146097 / 4800;
    }

    function as(units) {
        if (!this.isValid()) {
            return NaN;
        }
        var days;
        var months;
        var milliseconds = this._milliseconds;

        units = normalizeUnits(units);

        if (units === 'month' || units === 'quarter' || units === 'year') {
            days = this._days + milliseconds / 864e5;
            months = this._months + daysToMonths(days);
            switch (units) {
                case 'month':
                    return months;
                case 'quarter':
                    return months / 3;
                case 'year':
                    return months / 12;
            }
        } else {
            // handle milliseconds separately because of floating point math errors (issue #1867)
            days = this._days + Math.round(monthsToDays(this._months));
            switch (units) {
                case 'week':
                    return days / 7 + milliseconds / 6048e5;
                case 'day':
                    return days + milliseconds / 864e5;
                case 'hour':
                    return days * 24 + milliseconds / 36e5;
                case 'minute':
                    return days * 1440 + milliseconds / 6e4;
                case 'second':
                    return days * 86400 + milliseconds / 1000;
                // Math.floor prevents floating point math errors here
                case 'millisecond':
                    return Math.floor(days * 864e5) + milliseconds;
                default:
                    throw new Error('Unknown unit ' + units);
            }
        }
    }

    // TODO: Use this.as('ms')?
    function valueOf$1() {
        if (!this.isValid()) {
            return NaN;
        }
        return (
            this._milliseconds +
            this._days * 864e5 +
            (this._months % 12) * 2592e6 +
            toInt(this._months / 12) * 31536e6
        );
    }

    function makeAs(alias) {
        return function () {
            return this.as(alias);
        };
    }

    var asMilliseconds = makeAs('ms');
    var asSeconds = makeAs('s');
    var asMinutes = makeAs('m');
    var asHours = makeAs('h');
    var asDays = makeAs('d');
    var asWeeks = makeAs('w');
    var asMonths = makeAs('M');
    var asQuarters = makeAs('Q');
    var asYears = makeAs('y');

    function clone$1() {
        return createDuration(this);
    }

    function get$2(units) {
        units = normalizeUnits(units);
        return this.isValid() ? this[units + 's']() : NaN;
    }

    function makeGetter(name) {
        return function () {
            return this.isValid() ? this._data[name] : NaN;
        };
    }

    var milliseconds = makeGetter('milliseconds');
    var seconds = makeGetter('seconds');
    var minutes = makeGetter('minutes');
    var hours = makeGetter('hours');
    var days = makeGetter('days');
    var months = makeGetter('months');
    var years = makeGetter('years');

    function weeks() {
        return absFloor(this.days() / 7);
    }

    var round = Math.round;
    var thresholds = {
        ss: 44, // a few seconds to seconds
        s: 45, // seconds to minute
        m: 45, // minutes to hour
        h: 22, // hours to day
        d: 26, // days to month
        M: 11 // months to year
    };

    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
    }

    function relativeTime$1(posNegDuration, withoutSuffix, locale) {
        var duration = createDuration(posNegDuration).abs();
        var seconds = round(duration.as('s'));
        var minutes = round(duration.as('m'));
        var hours = round(duration.as('h'));
        var days = round(duration.as('d'));
        var months = round(duration.as('M'));
        var years = round(duration.as('y'));

        var a = seconds <= thresholds.ss && ['s', seconds] ||
            seconds < thresholds.s && ['ss', seconds] ||
            minutes <= 1 && ['m'] ||
            minutes < thresholds.m && ['mm', minutes] ||
            hours <= 1 && ['h'] ||
            hours < thresholds.h && ['hh', hours] ||
            days <= 1 && ['d'] ||
            days < thresholds.d && ['dd', days] ||
            months <= 1 && ['M'] ||
            months < thresholds.M && ['MM', months] ||
            years <= 1 && ['y'] || ['yy', years];

        a[2] = withoutSuffix;
        a[3] = +posNegDuration > 0;
        a[4] = locale;
        return substituteTimeAgo.apply(null, a);
    }

    // This function allows you to set the rounding function for relative time strings
    function getSetRelativeTimeRounding(roundingFunction) {
        if (roundingFunction === undefined) {
            return round;
        }
        if (typeof (roundingFunction) === 'function') {
            round = roundingFunction;
            return true;
        }
        return false;
    }

    // This function allows you to set a threshold for relative time strings
    function getSetRelativeTimeThreshold(threshold, limit) {
        if (thresholds[threshold] === undefined) {
            return false;
        }
        if (limit === undefined) {
            return thresholds[threshold];
        }
        thresholds[threshold] = limit;
        if (threshold === 's') {
            thresholds.ss = limit - 1;
        }
        return true;
    }

    function humanize(withSuffix) {
        if (!this.isValid()) {
            return this.localeData().invalidDate();
        }

        var locale = this.localeData();
        var output = relativeTime$1(this, !withSuffix, locale);

        if (withSuffix) {
            output = locale.pastFuture(+this, output);
        }

        return locale.postformat(output);
    }

    var abs$1 = Math.abs;

    function sign(x) {
        return ((x > 0) - (x < 0)) || +x;
    }

    function toISOString$1() {
        // for ISO strings we do not use the normal bubbling rules:
        //  * milliseconds bubble up until they become hours
        //  * days do not bubble at all
        //  * months bubble up until they become years
        // This is because there is no context-free conversion between hours and days
        // (think of clock changes)
        // and also not between days and months (28-31 days per month)
        if (!this.isValid()) {
            return this.localeData().invalidDate();
        }

        var seconds = abs$1(this._milliseconds) / 1000;
        var days = abs$1(this._days);
        var months = abs$1(this._months);
        var minutes, hours, years;

        // 3600 seconds -> 60 minutes -> 1 hour
        minutes = absFloor(seconds / 60);
        hours = absFloor(minutes / 60);
        seconds %= 60;
        minutes %= 60;

        // 12 months -> 1 year
        years = absFloor(months / 12);
        months %= 12;


        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
        var Y = years;
        var M = months;
        var D = days;
        var h = hours;
        var m = minutes;
        var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
        var total = this.asSeconds();

        if (!total) {
            // this is the same as C#'s (Noda) and python (isodate)...
            // but not other JS (goog.date)
            return 'P0D';
        }

        var totalSign = total < 0 ? '-' : '';
        var ymSign = sign(this._months) !== sign(total) ? '-' : '';
        var daysSign = sign(this._days) !== sign(total) ? '-' : '';
        var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';

        return totalSign + 'P' +
            (Y ? ymSign + Y + 'Y' : '') +
            (M ? ymSign + M + 'M' : '') +
            (D ? daysSign + D + 'D' : '') +
            ((h || m || s) ? 'T' : '') +
            (h ? hmsSign + h + 'H' : '') +
            (m ? hmsSign + m + 'M' : '') +
            (s ? hmsSign + s + 'S' : '');
    }

    var proto$2 = Duration.prototype;

    proto$2.isValid = isValid$1;
    proto$2.abs = abs;
    proto$2.add = add$1;
    proto$2.subtract = subtract$1;
    proto$2.as = as;
    proto$2.asMilliseconds = asMilliseconds;
    proto$2.asSeconds = asSeconds;
    proto$2.asMinutes = asMinutes;
    proto$2.asHours = asHours;
    proto$2.asDays = asDays;
    proto$2.asWeeks = asWeeks;
    proto$2.asMonths = asMonths;
    proto$2.asQuarters = asQuarters;
    proto$2.asYears = asYears;
    proto$2.valueOf = valueOf$1;
    proto$2._bubble = bubble;
    proto$2.clone = clone$1;
    proto$2.get = get$2;
    proto$2.milliseconds = milliseconds;
    proto$2.seconds = seconds;
    proto$2.minutes = minutes;
    proto$2.hours = hours;
    proto$2.days = days;
    proto$2.weeks = weeks;
    proto$2.months = months;
    proto$2.years = years;
    proto$2.humanize = humanize;
    proto$2.toISOString = toISOString$1;
    proto$2.toString = toISOString$1;
    proto$2.toJSON = toISOString$1;
    proto$2.locale = locale;
    proto$2.localeData = localeData;

    proto$2.toIsoString = deprecate(
        'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
        toISOString$1);
    proto$2.lang = lang;

    // Side effect imports

    // FORMATTING

    addFormatToken('X', 0, 0, 'unix');
    addFormatToken('x', 0, 0, 'valueOf');

    // PARSING

    addRegexToken('x', matchSigned);
    addRegexToken('X', matchTimestamp);
    addParseToken('X', function (input, array, config) {
        config._d = new Date(parseFloat(input, 10) * 1000);
    });
    addParseToken('x', function (input, array, config) {
        config._d = new Date(toInt(input));
    });

    // Side effect imports


    hooks.version = '2.24.0';

    setHookCallback(createLocal);

    hooks.fn = proto;
    hooks.min = min;
    hooks.max = max;
    hooks.now = now;
    hooks.utc = createUTC;
    hooks.unix = createUnix;
    hooks.months = listMonths;
    hooks.isDate = isDate;
    hooks.locale = getSetGlobalLocale;
    hooks.invalid = createInvalid;
    hooks.duration = createDuration;
    hooks.isMoment = isMoment;
    hooks.weekdays = listWeekdays;
    hooks.parseZone = createInZone;
    hooks.localeData = getLocale;
    hooks.isDuration = isDuration;
    hooks.monthsShort = listMonthsShort;
    hooks.weekdaysMin = listWeekdaysMin;
    hooks.defineLocale = defineLocale;
    hooks.updateLocale = updateLocale;
    hooks.locales = listLocales;
    hooks.weekdaysShort = listWeekdaysShort;
    hooks.normalizeUnits = normalizeUnits;
    hooks.relativeTimeRounding = getSetRelativeTimeRounding;
    hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
    hooks.calendarFormat = getCalendarFormat;
    hooks.prototype = proto;

    // currently HTML5 input type only supports 24-hour formats
    hooks.HTML5_FMT = {
        DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // 
        DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // 
        DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // 
        DATE: 'YYYY-MM-DD', // 
        TIME: 'HH:mm', // 
        TIME_SECONDS: 'HH:mm:ss', // 
        TIME_MS: 'HH:mm:ss.SSS', // 
        WEEK: 'GGGG-[W]WW', // 
        MONTH: 'YYYY-MM' // 
    };

    return hooks;

})));

添加定时器

1
2
3

data {
timer: null
}

添加定时执行控制方法

/**
  * 定点定时刷新
  * @timeFixedArr：Array需要刷新的时间点，格式如['08:30:00','12:00:05']
  * @delayTime: Number 延迟的ms，在固定的实际点后多少ms内都只执行一次
  * @executed: true代表需要定时刷新的方法是否执行了,后面纵使在设定时间范围内也不执行自动刷新
  * @tickerFn：需要定时刷新的方法
* */
intervalFixedPointTaskFn({timeFixedArr = [], delayTime = 1000, executed = true}, tickerFn) {
    this.timer && clearInterval(this.timer) // 清除定时器
    this.timer = setInterval(() => {
        let currentTime = new Date().getTime() // 当前时间
        let currentYMD = moment(currentTime).format('YYYY-MM-DD') // 当前年月日
        let refresh = false // 判断是否需要刷新
        // 判断是否在设定的时间范围内
        let count = 0 // 记录不在设定范围内的数量
        for (let i = 0; i < timeFixedArr.length; i++) {
            let item = timeFixedArr[i] // 固定的时分秒
            let setTime = new Date(`${currentYMD} ${item}`).getTime() // 完整时间
            if (currentTime >= setTime && currentTime <= (setTime + delayTime)) { // 没有刷新过且在设定时间范围内 - 刷新
                if (!executed) { // 只执行一次
                    refresh = true
                }
                break
            } else {
                count++
            }
        }

        if (count === timeFixedArr.length) {
            executed = false
        }

        if (refresh) {
            executed = true
            console.log(`${moment(currentTime).format('YYYY-MM-DD HH:mm:ss')} 执行定时任务.... 执行方法 ${tickerFn}`)
            tickerFn && tickerFn()
        }

    }, 1000)
},

添加需要定时执行的方法

// 所有接口，以一个定时速度刷新
htcfAllFunction() {
    console.log("开始执行定时任务")
    // 需要添加的内容
    this.timer && clearInterval(this.timer)
    // 多个请求的方法，这里的catchFun方法只是为了遇到请求失败的请求时继续往下执行可以去掉
    Promise.all(catchFun([this.zbxx(), this.qwxx(), this.qwdj(), this.zyyjxxList(), this.jrmgjqList(), this.shldjqList()])).then(res => {
        if (res[3] > 4) {
            seamscroll.init({
                dom: document.getElementById('zyyjxx_review_box_scroll'),
                step: 0.1, //数值越大速度滚动越快
            })
        }
        if (res[5] > 7) {
            seamscroll.init({
                dom: document.getElementById('shldjq_review_box_scroll'),
                step: 0.1, //数值越大速度滚动越快
            })
        }
        if (res[4] > 3) {
            // 添加样式
            seamscroll.init({
                dom: document.getElementById('jrmgjq_review_box_scroll'),
                step: 0.1, //数值越大速度滚动越快
            })
        }
    }).catch(err => {
    }).finally(() => {
        // 需要添加的内容
        this.intervalFixedPointTaskFn({
            timeFixedArr: ['13:19:00', '13:20:00', '13:21:00'],
            delayTime: 1000,
            executed: true
        }, this.htcfAllFunction)
    })
},

定时器销毁

1
2
3

beforeDestroy() {
    this.timer && clearInterval(this.timer)
},

共赴良策

spring boot项目excel导出功能封装——5.导入带进度以及忽略错误

普通带进度的导入

异步导入

数据预览和确认导入

spring boot项目excel导出功能封装——4.导入

说在前面

使用说明

普通导入

带验证的导入，让用户和开发知道导入数据的哪一行存在问题

图片导入

嵌套对象导入

嵌套对象多行聚合导入

spring boot项目excel导出功能封装——3.图表导出

说在前面

使用说明

折线图

柱状图（纵向）

条形图（横向）

饼图

面积图

多个独立图表导出

spring boot项目excel导出功能封装——2.高级导出

说在前面

使用说明

合并单元格

数据脱敏

导出进度

冻结窗格和筛选

图标集

Excel 加密

多 Sheet 关联导出

嵌套对象

嵌套对象自动横展开

嵌套对象垂直展开

动态表头

spring boot项目excel导出功能封装——1.简单导出

说在前面

使用说明

基本导出

空表头导出

只导出添加了@ExcelProperty注解的字段

多 Sheet 导出

设定表格的列宽和行高

自动行号

数据验证功能

条件样式

导出数据字典转换

带图片的导出

在群晖上安装appflowy，一个带ai的自托管的云笔记应用，支持多端同步

情况说明

首先贴配置

docker-compose

nginx.conf

env

导入docker-compose并构建启动

群晖的反向代理

最后是路由器的端口映射

成果

在把qq表情包弄到微信中时，发现了百度网盘整的烂活

使用claude code + cloudflare上线一个工具下载说明站

将要使用的工具

前景提要

实现流程

使用提示词开始创建网站

使用github进行管理

完善网站内容并推送代码

部署发布网站

部署发布

打开cloudflare

网站一览

kkfileview漏洞修复及加固

重点来了

今天看了下日志

查了下攻击者

无需服务器部署网站

Serverless

Edge One

1.在腾讯云的控制台中找到这个功能：

2.开通功能

只导出添加了`@ExcelProperty`注解的字段

借助cloudflare的Workers 和 Pages创建workers

在目录/etc/docker/registry目录下创建config.yml

叔叔别拉了我害怕

公鸡泻药澡堂半年假