feat:zlb接口

src/main/java/com/xiang/common/utils/ImageUtils.java

@@ -0,0 +1,68 @@
+package com.xiang.common.utils;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Base64;
+
+/**
+ * @Author: xiang
+ * @Date: 2026-05-08 08:56
+ */
+public class ImageUtils {
+    /**
+     * 将 Base64 图片写入文件
+     * @param base64String Base64 编码的图片字符串
+     * @param outputPath 输出文件路径
+     */
+    public static void saveBase64Image(String base64String, String outputPath) {
+        try {
+            // 处理可能包含前缀的 Base64（如 data:image/png;base64,）
+            String base64Data = extractBase64Data(base64String);
+
+            // 解码 Base64
+            byte[] imageBytes = Base64.getDecoder().decode(base64Data);
+
+            // 写入文件
+            try (FileOutputStream fos = new FileOutputStream(outputPath)) {
+                fos.write(imageBytes);
+            }
+
+            System.out.println("图片已保存至: " + outputPath);
+
+        } catch (IllegalArgumentException e) {
+            System.err.println("Base64 解码失败: " + e.getMessage());
+        } catch (IOException e) {
+            System.err.println("文件写入失败: " + e.getMessage());
+        }
+    }
+    /**
+     * 提取纯 Base64 数据（去除前缀）
+     */
+    private static String extractBase64Data(String base64String) {
+        if (base64String == null || base64String.isEmpty()) {
+            throw new IllegalArgumentException("Base64 字符串不能为空");
+        }
+
+        // 检查是否包含 data:image/xxx;base64, 前缀
+        if (base64String.contains(",")) {
+            return base64String.split(",", 2)[1];
+        }
+
+        return base64String;
+    }
+
+    /**
+     * 从 Base64 字符串中获取图片类型
+     */
+    public static String getImageType(String base64String) {
+        if (base64String.startsWith("data:image/")) {
+            String type = base64String.substring(11, base64String.indexOf(";"));
+            return type; // 返回 png, jpeg, gif 等
+        }
+        return "png"; // 默认类型
+    }
+
+    public static void main(String[] args) {
+
+    }
+}

src/main/java/com/xiang/common/utils/ZlbCaptchaTrackDebugger.java

@@ -0,0 +1,361 @@
+package com.xiang.common.utils;
+
+import com.xiang.common.pojo.jntyzx.zlb.ZlbOrderInfo;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * ZLB 验证码轨迹调试器。
+ * 输入原始图片和轨迹点，输出控制台预览与带标注调试图。
+ */
+@Slf4j
+public class ZlbCaptchaTrackDebugger {
+
+    private static final DateTimeFormatter FILE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss_SSS");
+    private static final int DEFAULT_CONSOLE_WIDTH = 84;
+    private static final int DEFAULT_CONSOLE_HEIGHT = 24;
+    private static final Path OUTPUT_DIR = Paths.get("logs", "script", "track-debug");
+    private static final String DEFAULT_REQUEST_ID = "debug-demo";
+    private static final String DEFAULT_COORDINATE_TEXT = "226,89|76,62|125,101|26,114";
+    private static final Path DEFAULT_IMAGE_FILE = Paths.get("src", "main", "resources", "image.txt");
+
+    private ZlbCaptchaTrackDebugger() {
+    }
+
+    public static DebugResult debug(String base64Image,
+                                    List<String> rawTrackList,
+                                    List<ZlbOrderInfo.ZlbData.TrackList> generatedTrackList,
+                                    String requestId) {
+        try {
+            BufferedImage originalImage = decodeBase64Image(base64Image);
+            List<Point> rawPoints = parseRawTrackList(rawTrackList);
+            String consolePreview = buildConsolePreview(originalImage, rawPoints, generatedTrackList, requestId);
+            String debugImagePath = exportDebugImage(originalImage, rawPoints, generatedTrackList, requestId);
+            return new DebugResult(consolePreview, debugImagePath);
+        } catch (Exception e) {
+            log.warn("生成 ZLB 验证码轨迹调试信息失败", e);
+            return new DebugResult(null, null);
+        }
+    }
+
+    public static ExecutionResult execute(String imageBase64, String coordinateText, String requestId) {
+        List<String> rawTrackList = ZlbCaptchaTrackUtil.parseCoordinateText(coordinateText);
+        List<ZlbOrderInfo.ZlbData.TrackList> generatedTrackList = ZlbCaptchaTrackUtil.generateBezierTrackList(rawTrackList);
+        DebugResult debugResult = debug(imageBase64, rawTrackList, generatedTrackList, requestId);
+        return new ExecutionResult(generatedTrackList, debugResult.getConsolePreview(), debugResult.getDebugImagePath());
+    }
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            runLocalSample();
+            return;
+        }
+        if (args.length < 3) {
+            System.out.println("Usage: ZlbCaptchaTrackDebugger <requestId> <coordinateText> <imageBase64>");
+            return;
+        }
+        ExecutionResult result = execute(args[2], args[1], args[0]);
+        System.out.println("trackList=" + result.getTrackListJson());
+        if (result.getConsolePreview() != null) {
+            System.out.println(result.getConsolePreview());
+        }
+        if (result.getDebugImagePath() != null) {
+            System.out.println("debugImagePath=" + result.getDebugImagePath());
+        }
+    }
+
+    public static void runLocalSample() {
+        try {
+            String imageBase64 = loadDefaultImageBase64();
+            ImageUtils.saveBase64Image(imageBase64, OUTPUT_DIR.toFile() + "image.jpeg");
+            ExecutionResult result = execute(imageBase64, DEFAULT_COORDINATE_TEXT, DEFAULT_REQUEST_ID);
+            System.out.println("trackList=" + result.getTrackListJson());
+            if (result.getConsolePreview() != null) {
+                System.out.println(result.getConsolePreview());
+            }
+            if (result.getDebugImagePath() != null) {
+                System.out.println("debugImagePath=" + result.getDebugImagePath());
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("运行本地样例失败，请先把 image base64 写入 " + DEFAULT_IMAGE_FILE.toAbsolutePath(), e);
+        }
+    }
+
+    private static String loadDefaultImageBase64() throws IOException {
+        return new String(Files.readAllBytes(DEFAULT_IMAGE_FILE), StandardCharsets.UTF_8).trim();
+    }
+
+    private static BufferedImage decodeBase64Image(String base64Image) throws IOException {
+        String base64Data = base64Image;
+        if (base64Image != null && base64Image.contains(",")) {
+            base64Data = base64Image.substring(base64Image.indexOf(',') + 1);
+        }
+        byte[] imageBytes = Base64.getDecoder().decode(base64Data);
+        try (ByteArrayInputStream inputStream = new ByteArrayInputStream(imageBytes)) {
+            BufferedImage image = ImageIO.read(inputStream);
+            if (image == null) {
+                throw new IOException("base64 图片解码结果为空");
+            }
+            return image;
+        }
+    }
+
+    private static List<Point> parseRawTrackList(List<String> rawTrackList) {
+        if (rawTrackList == null || rawTrackList.isEmpty()) {
+            return Collections.emptyList();
+        }
+        List<Point> points = new ArrayList<>(rawTrackList.size());
+        for (String item : rawTrackList) {
+            if (item == null || item.trim().isEmpty()) {
+                continue;
+            }
+            String[] split = item.split(",");
+            if (split.length < 2) {
+                continue;
+            }
+            points.add(new Point(Integer.parseInt(split[0].trim()), Integer.parseInt(split[1].trim())));
+        }
+        return points;
+    }
+
+    private static String buildConsolePreview(BufferedImage originalImage,
+                                              List<Point> rawPoints,
+                                              List<ZlbOrderInfo.ZlbData.TrackList> generatedTrackList,
+                                              String requestId) {
+        int width = originalImage.getWidth();
+        int height = originalImage.getHeight();
+        int consoleWidth = Math.min(DEFAULT_CONSOLE_WIDTH, Math.max(24, width));
+        int consoleHeight = Math.min(DEFAULT_CONSOLE_HEIGHT, Math.max(12, (int) Math.round((double) height / width * consoleWidth * 0.5d)));
+
+        char[][] canvas = new char[consoleHeight][consoleWidth];
+        for (int row = 0; row < consoleHeight; row++) {
+            for (int col = 0; col < consoleWidth; col++) {
+                canvas[row][col] = '.';
+            }
+        }
+
+        overlayRawPoints(canvas, rawPoints, width, height);
+        overlayGeneratedTrack(canvas, generatedTrackList, width, height);
+
+        StringBuilder preview = new StringBuilder();
+        preview.append('\n');
+        preview.append("===== ZLB CAPTCHA DEBUG =====").append('\n');
+        preview.append("requestId=").append(sanitizeFileName(requestId))
+                .append(", image=").append(width).append("x").append(height)
+                .append(", rawPoints=").append(rawPoints.size())
+                .append(", generatedPoints=").append(generatedTrackList == null ? 0 : generatedTrackList.size())
+                .append('\n');
+        preview.append("rawPoints=").append(buildRawPointSummary(rawPoints)).append('\n');
+        preview.append("generatedTrack=").append(buildTrackSummary(generatedTrackList)).append('\n');
+        preview.append("grid: R=raw point, C=click, M=move, B=overlap, .=empty").append('\n');
+        for (char[] chars : canvas) {
+            preview.append(chars).append('\n');
+        }
+        preview.append("================================").append('\n');
+        return preview.toString();
+    }
+
+    private static String exportDebugImage(BufferedImage originalImage,
+                                           List<Point> rawPoints,
+                                           List<ZlbOrderInfo.ZlbData.TrackList> generatedTrackList,
+                                           String requestId) throws IOException {
+        BufferedImage debugImage = new BufferedImage(
+                originalImage.getWidth(),
+                originalImage.getHeight(),
+                BufferedImage.TYPE_INT_ARGB
+        );
+        Graphics2D graphics = debugImage.createGraphics();
+        try {
+            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+            graphics.drawImage(originalImage, 0, 0, null);
+            drawGeneratedTrack(graphics, generatedTrackList);
+            drawRawPoints(graphics, rawPoints);
+            drawLegend(graphics);
+        } finally {
+            graphics.dispose();
+        }
+
+        Files.createDirectories(OUTPUT_DIR);
+        String fileName = String.format(
+                "zlb_track_%s_%s.png",
+                sanitizeFileName(requestId),
+                FILE_TIME_FORMATTER.format(LocalDateTime.now())
+        );
+        Path outputPath = OUTPUT_DIR.resolve(fileName).toAbsolutePath();
+        ImageIO.write(debugImage, "png", outputPath.toFile());
+        return outputPath.toString();
+    }
+
+    private static void overlayRawPoints(char[][] canvas, List<Point> rawPoints, int width, int height) {
+        for (Point rawPoint : rawPoints) {
+            int col = scaleToConsole(rawPoint.x, width, canvas[0].length);
+            int row = scaleToConsole(rawPoint.y, height, canvas.length);
+            paintOverlay(canvas, row, col, 'R');
+        }
+    }
+
+    private static void overlayGeneratedTrack(char[][] canvas,
+                                              List<ZlbOrderInfo.ZlbData.TrackList> generatedTrackList,
+                                              int width,
+                                              int height) {
+        if (generatedTrackList == null) {
+            return;
+        }
+        for (ZlbOrderInfo.ZlbData.TrackList trackPoint : generatedTrackList) {
+            int col = scaleToConsole(trackPoint.getX(), width, canvas[0].length);
+            int row = scaleToConsole(trackPoint.getY(), height, canvas.length);
+            char mark = "click".equalsIgnoreCase(trackPoint.getType()) ? 'C' : 'M';
+            paintOverlay(canvas, row, col, mark);
+        }
+    }
+
+    private static void paintOverlay(char[][] canvas, int row, int col, char mark) {
+        char current = canvas[row][col];
+        if (current == 'R' || current == 'C' || current == 'M' || current == 'B') {
+            canvas[row][col] = current == mark ? current : 'B';
+            return;
+        }
+        canvas[row][col] = mark;
+    }
+
+    private static int scaleToConsole(int value, int originalSize, int consoleSize) {
+        if (originalSize <= 1) {
+            return 0;
+        }
+        int scaled = (int) Math.round(value * (consoleSize - 1d) / (originalSize - 1d));
+        return Math.max(0, Math.min(consoleSize - 1, scaled));
+    }
+
+    private static String buildTrackSummary(List<ZlbOrderInfo.ZlbData.TrackList> generatedTrackList) {
+        if (generatedTrackList == null || generatedTrackList.isEmpty()) {
+            return "[]";
+        }
+        StringBuilder summary = new StringBuilder("[");
+        for (int i = 0; i < generatedTrackList.size(); i++) {
+            ZlbOrderInfo.ZlbData.TrackList trackPoint = generatedTrackList.get(i);
+            if (i > 0) {
+                summary.append(", ");
+            }
+            summary.append("{x=").append(trackPoint.getX())
+                    .append(", y=").append(trackPoint.getY())
+                    .append(", type=").append(trackPoint.getType())
+                    .append(", t=").append(trackPoint.getT())
+                    .append('}');
+        }
+        summary.append(']');
+        return summary.toString();
+    }
+
+    private static String buildRawPointSummary(List<Point> rawPoints) {
+        if (rawPoints == null || rawPoints.isEmpty()) {
+            return "[]";
+        }
+        StringBuilder summary = new StringBuilder("[");
+        for (int i = 0; i < rawPoints.size(); i++) {
+            Point point = rawPoints.get(i);
+            if (i > 0) {
+                summary.append(", ");
+            }
+            summary.append("P").append(i)
+                    .append("{x=").append(point.x)
+                    .append(", y=").append(point.y)
+                    .append('}');
+        }
+        summary.append(']');
+        return summary.toString();
+    }
+
+    private static void drawRawPoints(Graphics2D graphics, List<Point> rawPoints) {
+        graphics.setFont(new Font("SansSerif", Font.BOLD, 13));
+        graphics.setStroke(new BasicStroke(2.5f));
+        for (int i = 0; i < rawPoints.size(); i++) {
+            Point point = rawPoints.get(i);
+            graphics.setColor(new Color(30, 144, 255, 210));
+            graphics.drawOval(point.x - 8, point.y - 8, 16, 16);
+            graphics.setColor(Color.WHITE);
+            graphics.drawString("P" + i, point.x + 8, point.y - 8);
+        }
+    }
+
+    private static void drawGeneratedTrack(Graphics2D graphics, List<ZlbOrderInfo.ZlbData.TrackList> generatedTrackList) {
+        if (generatedTrackList == null || generatedTrackList.isEmpty()) {
+            return;
+        }
+        graphics.setFont(new Font("SansSerif", Font.PLAIN, 12));
+        graphics.setStroke(new BasicStroke(2.5f));
+        for (int i = 0; i < generatedTrackList.size(); i++) {
+            ZlbOrderInfo.ZlbData.TrackList current = generatedTrackList.get(i);
+            if (i > 0) {
+                ZlbOrderInfo.ZlbData.TrackList previous = generatedTrackList.get(i - 1);
+                graphics.setColor(new Color(255, 99, 71, 180));
+                graphics.drawLine(previous.getX(), previous.getY(), current.getX(), current.getY());
+            }
+            Color pointColor = "click".equalsIgnoreCase(current.getType())
+                    ? new Color(220, 20, 60, 220)
+                    : new Color(255, 165, 0, 220);
+            graphics.setColor(pointColor);
+            graphics.fillOval(current.getX() - 5, current.getY() - 5, 10, 10);
+            graphics.setColor(Color.WHITE);
+            graphics.drawOval(current.getX() - 5, current.getY() - 5, 10, 10);
+//            graphics.drawString(current.getType() + "(" + current.getT() + ")", current.getX() + 6, current.getY() + 16);
+        }
+    }
+
+    private static void drawLegend(Graphics2D graphics) {
+        int boxX = 12;
+        int boxY = 12;
+        int boxWidth = 250;
+        int boxHeight = 62;
+//        graphics.setColor(new Color(0, 0, 0, 135));
+//        graphics.fillRoundRect(boxX, boxY, boxWidth, boxHeight, 12, 12);
+//        graphics.setColor(Color.WHITE);
+//        graphics.setFont(new Font("SansSerif", Font.BOLD, 13));
+//        graphics.drawString("Blue: raw points", boxX + 12, boxY + 22);
+//        graphics.drawString("Red: click track", boxX + 12, boxY + 40);
+//        graphics.drawString("Orange: move track", boxX + 12, boxY + 58);
+    }
+
+    private static String sanitizeFileName(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            return "unknown";
+        }
+        return value.replaceAll("[^a-zA-Z0-9_-]", "_");
+    }
+
+    @Data
+    @AllArgsConstructor
+    public static class DebugResult {
+        private String consolePreview;
+        private String debugImagePath;
+    }
+
+    @Data
+    @AllArgsConstructor
+    public static class ExecutionResult {
+        private List<ZlbOrderInfo.ZlbData.TrackList> trackList;
+        private String consolePreview;
+        private String debugImagePath;
+
+        public String getTrackListJson() {
+            return com.alibaba.fastjson2.JSON.toJSONString(trackList);
+        }
+    }
+}

src/main/java/com/xiang/common/utils/ZlbCaptchaTrackUtil.java

@@ -0,0 +1,117 @@
+package com.xiang.common.utils;
+
+import com.xiang.common.pojo.jntyzx.zlb.ZlbOrderInfo;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * 浙里办验证码轨迹生成工具。
+ */
+public class ZlbCaptchaTrackUtil {
+
+    private ZlbCaptchaTrackUtil() {
+    }
+
+    public static List<ZlbOrderInfo.ZlbData.TrackList> generateBezierTrackList(List<String> trackList) {
+        List<ZlbOrderInfo.ZlbData.TrackList> result = new ArrayList<>();
+        if (trackList == null || trackList.isEmpty()) {
+            return result;
+        }
+
+        for (int i = 0; i < trackList.size(); i++) {
+            int[] currentPoint = parseTrackCoordinate(trackList.get(i));
+            int clickTime = result.isEmpty()
+                    ? randomBetween(1800, 2200)
+                    : result.get(result.size() - 1).getT() + randomBetween(25, 60);
+            result.add(buildTrackPoint(currentPoint[0], currentPoint[1], clickTime, "click"));
+
+            if (i < trackList.size() - 1) {
+                int[] nextPoint = parseTrackCoordinate(trackList.get(i + 1));
+                int moveStartTime = result.get(result.size() - 1).getT();
+                int moveDuration = randomBetween(800, 1200);
+                List<int[]> movePoints = buildBezierMovePoints(currentPoint[0], currentPoint[1], nextPoint[0], nextPoint[1]);
+                for (int moveIndex = 0; moveIndex < movePoints.size(); moveIndex++) {
+                    int[] movePoint = movePoints.get(moveIndex);
+                    int moveTime = moveStartTime + (int) Math.round((double) moveDuration * (moveIndex + 1) / (movePoints.size() + 1));
+                    result.add(buildTrackPoint(movePoint[0], movePoint[1], moveTime, "move"));
+                }
+            }
+        }
+        return result;
+    }
+
+    public static List<String> parseCoordinateText(String coordinateText) {
+        if (coordinateText == null || coordinateText.trim().isEmpty()) {
+            return Collections.emptyList();
+        }
+        String normalized = coordinateText.replace("\n", "|").replace(";", "|");
+        String[] parts = normalized.split("\\|");
+        List<String> result = new ArrayList<>();
+        for (String part : parts) {
+            if (part != null && !part.trim().isEmpty()) {
+                result.add(part.trim());
+            }
+        }
+        return result;
+    }
+
+    private static int[] parseTrackCoordinate(String track) {
+        String[] coordinateArr = track.split(",");
+        return new int[]{
+                Integer.parseInt(coordinateArr[0].trim()),
+                Integer.parseInt(coordinateArr[1].trim())
+        };
+    }
+
+    private static List<int[]> buildBezierMovePoints(int fromX, int fromY, int toX, int toY) {
+        int movePointCount = randomBetween(3, 5);
+        double dx = toX - fromX;
+        double dy = toY - fromY;
+        double distance = Math.max(1d, Math.hypot(dx, dy));
+        double normalX = -dy / distance;
+        double normalY = dx / distance;
+        double direction = ThreadLocalRandom.current().nextBoolean() ? 1d : -1d;
+        double offset = Math.min(28d, Math.max(6d, distance * ThreadLocalRandom.current().nextDouble(0.08d, 0.22d))) * direction;
+        double controlX = (fromX + toX) / 2d + normalX * offset;
+        double controlY = (fromY + toY) / 2d + normalY * offset;
+
+        List<int[]> movePoints = new ArrayList<>(movePointCount);
+        for (int i = 1; i <= movePointCount; i++) {
+            double progress = easeInOutCubic((double) i / (movePointCount + 1));
+            int x = (int) Math.round(
+                    Math.pow(1 - progress, 2) * fromX
+                            + 2 * (1 - progress) * progress * controlX
+                            + Math.pow(progress, 2) * toX
+            );
+            int y = (int) Math.round(
+                    Math.pow(1 - progress, 2) * fromY
+                            + 2 * (1 - progress) * progress * controlY
+                            + Math.pow(progress, 2) * toY
+            );
+            movePoints.add(new int[]{x, y});
+        }
+        return movePoints;
+    }
+
+    private static double easeInOutCubic(double value) {
+        return value < 0.5d
+                ? 4d * value * value * value
+                : 1d - Math.pow(-2d * value + 2d, 3d) / 2d;
+    }
+
+    private static ZlbOrderInfo.ZlbData.TrackList buildTrackPoint(int x, int y, int t, String type) {
+        ZlbOrderInfo.ZlbData.TrackList data = new ZlbOrderInfo.ZlbData.TrackList();
+        data.setX(x);
+        data.setY(y);
+        data.setT(t);
+        data.setType(type);
+        return data;
+    }
+
+    private static int randomBetween(int minInclusive, int maxInclusive) {
+        return ThreadLocalRandom.current().nextInt(minInclusive, maxInclusive + 1);
+    }
+}

src/main/java/com/xiang/service/module/jntyzx/zlb/schedule/ZlbOrderTask.java

@@ -2,8 +2,10 @@ package com.xiang.service.module.jntyzx.zlb.schedule;
 
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.xiang.common.enums.ScheduleEnums;
+import com.xiang.common.exception.BusinessException;
 import com.xiang.common.factory.JntyzxDingTalkFactory;
 import com.xiang.common.factory.schedule.BaseScheduleTaskTemplate;
 import com.xiang.common.pojo.jntyzx.zlb.ZlbTokenInfo;
@@ -18,12 +20,9 @@ import com.xiang.service.module.jntyzx.zlb.service.ZlbService;
 import com.xiang.service.module.jntyzx.zlb.service.ZlbTokenInfoService;
 import com.xiang.service.module.jntyzx.zlb.service.ZlbUserInfoService;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Component;
 
-import javax.annotation.Resource;
-import java.io.IOException;
 import java.time.Duration;
 import java.time.LocalTime;
 import java.util.Date;
@@ -101,6 +100,10 @@ public class ZlbOrderTask extends BaseScheduleTaskTemplate {
         String siteOrderDetailsStr = zlbService.buildSiteOrder(zlbUserInfo, secretKey, day);
         Map<String, String> headers = zlbService.getHeaders(zlbTokenInfo.getTokenId());
         String newOrderJson = zlbService.buildNewOrder(siteOrderDetailsStr, client);
+        if (StringUtils.isBlank(newOrderJson)) {
+            log.info("构建订单参数异常:{}", siteOrderDetailsStr);
+            throw new BusinessException("");
+        }
         ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
         //计算9点到现在的时间差
         //获取江体当前时间

src/main/java/com/xiang/service/module/jntyzx/zlb/service/ZlbServiceImpl.java

@@ -8,9 +8,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.google.common.collect.Lists;
 import com.xiang.common.factory.JntyzxDingTalkFactory;
-import com.xiang.common.pojo.TrackPoint;
 import com.xiang.common.pojo.jntyzx.zlb.ZlbCaptchaResp;
 import com.xiang.common.pojo.jntyzx.zlb.ZlbOrderInfo;
 import com.xiang.common.pojo.jntyzx.zlb.ZlbOrderJson;
@@ -25,7 +23,7 @@ import com.xiang.common.utils.AESECBUtils;
 import com.xiang.common.utils.Base64ImageScaler;
 import com.xiang.common.utils.DateUtils;
 import com.xiang.common.utils.OkHttpUtil;
-import com.xiang.common.utils.TrajectoryUtil;
+import com.xiang.common.utils.ZlbCaptchaTrackUtil;
 import com.xiang.service.module.jntyzx.zlb.constants.ZlbUrlConstants;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -420,43 +418,7 @@ public class ZlbServiceImpl implements ZlbService {
     }
 
     private List<ZlbOrderInfo.ZlbData.TrackList> convert(List<String> trackList) {
-        int t = 0;
+        List<ZlbOrderInfo.ZlbData.TrackList> result = ZlbCaptchaTrackUtil.generateBezierTrackList(trackList);
-        List<ZlbOrderInfo.ZlbData.TrackList> result = Lists.newArrayList();
-
-        for (int i = 0; i < trackList.size(); i++) {
-            String currentTrack = trackList.get(i);
-            String nextTrack = null;
-            if (i != trackList.size() - 1) {
-                nextTrack = trackList.get(i + 1);
-            }
-            t += 100;
-            Integer currentX = Integer.parseInt(currentTrack.split(",")[0]);
-            Integer currentY = Integer.parseInt(currentTrack.split(",")[1]);
-            List<TrackPoint> trackPoints = TrajectoryUtil.generateClick(currentX, currentY, t);
-            for (TrackPoint trackPoint : trackPoints) {
-                if (StringUtils.equals(trackPoint.getType(), "click")) {
-                    ZlbOrderInfo.ZlbData.TrackList data = new ZlbOrderInfo.ZlbData.TrackList();
-                    data.setX(trackPoint.getX());
-                    data.setY(trackPoint.getY());
-                    data.setT(trackPoint.getT());
-                    data.setType(trackPoint.getType());
-                    result.add(data);
-                }
-            }
-            t += 500;
-            if (StringUtils.isNotBlank(nextTrack)) {
-                Integer nextX = Integer.parseInt(nextTrack.split(",")[0]);
-                Integer nextY = Integer.parseInt(nextTrack.split(",")[1]);
-                List<TrackPoint> nextTrackPoints = TrajectoryUtil.generateMove(currentX, currentY, nextX, nextY, t, 1200, 10);
-                TrackPoint trackPoint = nextTrackPoints.get(i + 1);
-                ZlbOrderInfo.ZlbData.TrackList data = new ZlbOrderInfo.ZlbData.TrackList();
-                data.setX(trackPoint.getX());
-                data.setY(trackPoint.getY());
-                data.setT(trackPoint.getT());
-                data.setType(trackPoint.getType());
-                result.add(data);
-            }
-        }
         log.info("生成的轨迹点结果:{}", JSON.toJSONString(result));
         return result;
     }
@@ -688,5 +650,3 @@ public class ZlbServiceImpl implements ZlbService {
         }
     }
 }
-
-