生成预览链接

// socket地址
ws(s)://{baseURL}/emh/ws/info?socketId={taksId}
// 举例,若域名配置了oss安全证书，则需要以 wss:// 开头
// ws://10.1.201.7:9999/emh/ws/info?socketId=aaaaaaaa
// wss://www.baidu.com/emh/ws/info?socketId=aaaaaaaa

{"code":0,"command":"UNCOMPRESS_FILE","data":"{\"status\":\"success\",\"percent\":\"100\",\"waitingLength\":\"0\",\"waitingTime\":\"0\"}"}
{"code":0,"command":"CONVERT_TASK","data":"{\"status\":\"processing\",\"waitingLength\":\"0\",\"waitingTime\":\"0\"}"}
{"code":0,"command":"CONVERT_TASK","data":"{\"status\":\"processing\",\"percent\":\"0\",\"waitingLength\":\"0\",\"waitingTime\":\"0\"}"}
{"code":0,"command":"CONVERT_TASK","data":"{\"status\":\"processing\",\"percent\":\"3\",\"waitingLength\":\"0\",\"waitingTime\":\"0\"}"}
{"code": 0,"command": "CONVERT_TASK","data": "{\"status\":\"success\",\"percent\":\"100\",\"waitingLength\":\"0\",\"waitingTime\":\"0\",\"previewUrl\":\"http://xxx.com/SView/sview3d.html?absoluteFileURL=t5TTERBU00uc3ZseA&fileType=svlx\"}"}

<!-- websocket客户端依赖 -->
<dependency>
    <groupId>org.java-websocket</groupId>
    <artifactId>Java-WebSocket</artifactId>
    <version>1.5.4</version>
</dependency>

package com.hoteam.sview.demo;

import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.JsonUtil;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

import java.net.URI;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * 文件转码 WebSocket 监听客户端
 * 配合 PreviewUrlDemo 使用，taskId 来自预览接口返回
 * 规则：
 *  1、任意command下 status=failed → 整个任务失败
 *  2、command=CONVERT_TASK && status=success →转码成功，取出previewUrl
 */
@Slf4j
public class PreviewWebSocketClient extends WebSocketClient {

    // 用于阻塞主线程，等待转码结果返回
    private final CountDownLatch latch = new CountDownLatch(1);
    // 最终结果
    private TranscodeResult transcodeResult;

    public PreviewWebSocketClient(URI serverUri) {
        super(serverUri);
    }

    /**
     * 阻塞等待转码结果，设置最长等待超时时间
     * @param timeout 超时数值
     * @param unit 时间单位
     * @return 转码结果
     * @throws InterruptedException 中断异常
     */
    public TranscodeResult waitForResult(long timeout, TimeUnit unit) throws InterruptedException {
        latch.await(timeout, unit);
        return transcodeResult;
    }

    @Override
    public void onOpen(ServerHandshake handshakedata) {
        log.info("WebSocket连接成功,地址:{}", getURI());
    }

    @Override
    public void onMessage(String message) {
        log.info("WebSocket收到原始消息：{}", message);
        try {
            // 1、解析外层消息
            WsOuterMsg outerMsg = JsonUtil.parse(message, WsOuterMsg.class);
            if (outerMsg == null || outerMsg.getCode() != 0) {
                log.warn("websocket返回业务异常,message:{}",message);
                return;
            }
            String command = outerMsg.getCommand();
            String dataStr = outerMsg.getData();
            if(StrUtil.isBlank(dataStr)){
                return;
            }
            // 2、解析data内层JSON字符串
            WsInnerMsg innerMsg = JsonUtil.parse(dataStr, WsInnerMsg.class);
            if(innerMsg == null){
                return;
            }
            String status = innerMsg.getStatus();
            Integer percent = innerMsg.getPercent();
            log.info("阶段:{}, 当前状态:{}, 进度:{}%",command,status,percent);

            // ========== 改动：任意阶段只要status=failed，直接判定整体失败 ==========
            if("failed".equals(status)){
                transcodeResult = new TranscodeResult(false,null,"任务执行失败，阶段："+ command);
                log.error("任务失败，command:{}",command);
                this.close();
                latch.countDown();
                return;
            }

            // ========== 成功判定：仍然必须是 CONVERT_TASK + success ==========
            if("CONVERT_TASK".equals(command) && "success".equals(status)){
                // 转码成功，取出预览地址
                transcodeResult = new TranscodeResult(true,innerMsg.getPreviewUrl(),null);
                log.info("文件转码成功！预览链接 = {}",innerMsg.getPreviewUrl());
                // 关闭连接，唤醒等待线程
                this.close();
                latch.countDown();
            }

            // UNCOMPRESS_FILE 阶段的success只代表解压完成，不结束监听，继续等待后续CONVERT_TASK消息

        } catch (Exception e) {
            log.error("WebSocket消息解析异常，msg={}",message,e);
        }
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        log.info("WebSocket连接关闭,code={},reason={}",code,reason);
        // 如果断开但是还没拿到结果，判定异常
        if(transcodeResult == null){
            transcodeResult = new TranscodeResult(false,null,"WebSocket提前断开连接");
            latch.countDown();
        }
    }

    @Override
    public void onError(Exception ex) {
        log.error("WebSocket通信异常",ex);
        transcodeResult = new TranscodeResult(false,null,"WebSocket发生异常："+ex.getMessage());
        latch.countDown();
    }


    // ===================== 实体类 =====================
    /**
     * WebSocket外层消息体
     */
    @Data
    public static class WsOuterMsg{
        private Integer code;
        private String command;
        /** data为JSON字符串，需要二次解析 */
        private String data;
    }

    /**
     * data内层消息体
     */
    @Data
    public static class WsInnerMsg{
        /** processing / success / failed */
        private String status;
        private Integer percent;
        private String waitingLength;
        private String waitingTime;
        /** 转码成功后返回预览url */
        private String previewUrl;
    }

    /**
     * 最终转码返回结果对象
     */
    @Data
    public static class TranscodeResult{
        private Boolean success;
        private String previewUrl;
        private String errorMsg;
        public TranscodeResult(Boolean success,String previewUrl,String errorMsg){
            this.success = success;
            this.previewUrl = previewUrl;
            this.errorMsg = errorMsg;
        }
    }

    // ===================== 调用示例 =====================
    public static void main(String[] args) throws Exception {
        String baseApi = "https://xxx.xxx.com";
        // 从上一步预览接口拿到的taskId
        String taskId = "aaaaaaaaaaaaaa";
        String socketUrl = baseApi + "/emh/ws/info?socketId=" + taskId;

        PreviewWebSocketClient wsClient = new PreviewWebSocketClient(new URI(socketUrl));
        wsClient.connect();

        // 阻塞等待转码结果，最长等待10分钟
        TranscodeResult result = wsClient.waitForResult(10, TimeUnit.MINUTES);

        if(result.getSuccess()){
            log.info("最终预览地址：{}",result.getPreviewUrl());
        }else{
            log.error("转码失败：{}",result.getErrorMsg());
        }
    }
}