Java Websocket客户端（JSR 365）连接问题

我试图使用JSR365 API在Java中使用一个websocket服务。此服务部署在其他第三方服务器上。因此，在调用此函数时，需要将身份验证令牌作为cookie传递到标头中。 一旦我调用此服务，就不会得到任何异常或错误。另外，org.java_websocket.client.WebSocketClient.connectBlocking（）始终返回假值。 由于此代码未给出任何错误或异常，因此很难理解原因以及如何进行故障排除以获得确切原因。 再加一句，我们从云端获取这些数据

package com.test.mams;

import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;

import javax.net.ssl.SSLContext;

import org.java_websocket.client.DefaultSSLWebSocketClientFactory;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft;
import org.java_websocket.drafts.Draft_17;
import org.java_websocket.handshake.ServerHandshake;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;

public class WebSocketClientTest extends WebSocketClient {
    public WebSocketClientTest(String url, Draft draft) throws URISyntaxException {
        super(new URI(url), draft);
    }

    public void getFirmAccountData(WebSocketClientTest client, String accessToken) throws ParseException,
            URISyntaxException, JsonMappingException, UnsupportedEncodingException, JsonProcessingException {
        Map<String, String> headers = null;
        if (accessToken != null && !accessToken.isEmpty()) {
            headers = new HashMap<String, String>();
            headers.put("Cookie", "Authorization=Bearer%20" + accessToken);
        }
        try {
            // load default java key store : jssecacerts
            SSLContext sslContext = null;
            sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, null, null);
            client.setWebSocketFactory(new DefaultSSLWebSocketClientFactory(sslContext));
            boolean connected = client.connectBlocking();
            System.out.println("Value of connected : " + connected);
        } catch (Exception e) {
            e.printStackTrace();
            client.close();
        }
    }

    public static void main(String[] args)
            throws URISyntaxException, UnsupportedEncodingException, JsonMappingException, JsonProcessingException {
        Draft draft = new Draft_17();
        WebSocketClientTest client = new WebSocketClientTest(
                "wss://referencedatacloudstreams.sit.test.net/streams/delivery/account", draft);
        try {
            client.getFirmAccountData(client, "OTgyMGI5ZDUtZGM5NC00NmY5LTg4OTMtMWFmY2I4MTEzMDU4");
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void onOpen(ServerHandshake handshakedata) {
        System.out.println("Connected");
    }

    @Override
    public void onMessage(String message) {
        try {
            boolean done = false;
            boolean completed = false;
            boolean error = false;
            boolean info = false;

            if (message.contains("\"status\": \"done\"")) {
                done = true;
            }
            if (message.contains("\"status\": \"complete\"")) {
                completed = true;
                done = true;
            }
            if (message.contains("\"status\": \"error\"") || message.contains("\"status\": \"warning\"")) {
                completed = false;
                done = false;
                error = true;
            }
            if (message.contains("\"status\": \"info\"")) {
                info = true;
            }

            if (done) {
                System.out.println("--DONE--   " + message);
                if (completed) {
                    System.out.println("--COMPLETED--   " + message);
                } else if (!error) {
                    // request next chunk until complete
                    this.send("{\"request\": " + 2000 + "}");
                }
            } else if (error) {
                System.out.println("Error/Warning message received :" + message);
                System.out.println("Closing web socket");
                this.close();
            } else if (info) {
                System.out.println("Received info message for subscription : " + message);
            }
        } catch (Throwable e) { // buffer.append sometimes throws out of memory exception , we have to catch it
                                // otherwise web socket will remain open.
            e.printStackTrace();
            this.close();
        }
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        try {
            System.out.println("Websocket Close params: " + "code:" + code + ", " + "reason:" + reason + ", "
                    + "remote:" + remote);
            if (code != 1000) {
                System.out.println("Websocket did not close normally.");
            } else {
                System.out.println("Web socket closed normally for subscription");
            }
        } catch (Exception e) {
            // System.out.println("Error occured in onClose call Back for subscription
            // "+subscriptionId,e);
            e.printStackTrace();
        }
    }

    @Override
    public void onError(Exception ex) {
        ex.printStackTrace();
    }
}

package com.test.mams；
导入java.io.UnsupportedEncodingException；
导入java.net.URI；
导入java.net.URISyntaxException；
导入java.text.ParseException；
导入java.util.HashMap；
导入java.util.Map；
导入javax.net.ssl.SSLContext；
导入org.java_websocket.client.DefaultSSLWebSocketClientFactory；
导入org.java_websocket.client.WebSocketClient；
导入org.java_websocket.drafts.Draft；
导入org.java_websocket.drafts.Draft_17；
导入org.java_websocket.handshake.ServerHandshake；
导入com.fasterxml.jackson.core.JsonProcessingException；
导入com.fasterxml.jackson.databind.JsonMappingException；
公共类WebSocketClientTest扩展了WebSocketClient{
publicWebSocketClientTest（字符串url，草稿）抛出URISyntaxException{
super（新的URI（url），草稿）；
}
public void getFirmAccountData（WebSocketClientTest客户端，字符串accessToken）引发ParseException，
URISyntaxException、JsonMappingException、UnsupportedEncodingException、JsonProcessingException{
映射头=空；
if（accessToken！=null&&！accessToken.isEmpty（））{
headers=newhashmap（）；
headers.put（“Cookie”，“授权=承载%20”+accessToken）；
}
试一试{
//加载默认java密钥存储：jssecacerts
SSLContext SSLContext=null；
sslContext=sslContext.getInstance（“TLS”）；
init（null，null，null）；
setWebSocketFactory（新的默认SSLWebSocketClientFactory（sslContext））；
boolean connected=client.connectBlocking（）；
System.out.println（“连接的值：“+连接的”）；
}捕获（例外e）{
e、 printStackTrace（）；
client.close（）；
}
}
公共静态void main（字符串[]args）
抛出URISyntaxException、UnsupportedEncodingException、JsonMappingException、JsonProcessingException{
草稿=新草稿_17（）；
WebSocketClientTest客户端=新建WebSocketClientTest(
"wss://referencedatacloudstreams.sit.test.net/streams/delivery/account“，草案）；
试一试{
client.getFirmAccountData（客户，“otgymgi5zdutzgm5nc00nmy5ltg4otmtmwfmy2mi4temtezmdu4”）；
}捕获（解析异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
@凌驾
公共打开（服务器握手握手数据）{
System.out.println（“已连接”）；
}
@凌驾
公共消息无效（字符串消息）{
试一试{
布尔完成=假；
布尔完成=假；
布尔错误=假；
布尔信息=假；
if（message.contains（“\”status\”：\“done\”））{
完成=正确；
}
if（message.contains（“\”status\：\”complete\”）{
完成=正确；
完成=正确；
}
if（message.contains（“\”status\“：\”error\”）| | message.contains（“\”status\“：\”warning\”））{
完成=错误；
完成=错误；
错误=真；
}
if（message.contains（“\”状态\“：\”信息\“））{
信息=真；
}
如果（完成）{
System.out.println（“--DONE--”+消息）；
如果（已完成）{
System.out.println（“--COMPLETED--”+消息）；
}否则如果（！错误）{
//请求下一个块，直到完成
send（“{\”请求\“：“+2000+”}”）；
}
}else if（错误）{
System.out.println（“收到错误/警告消息：“+消息”）；
System.out.println（“关闭web套接字”）；
这个。关闭（）；
}其他如果（信息）{
System.out.println（“收到的订阅信息：“+消息”）；
}
}catch（Throwable e）{//buffer.append有时抛出内存不足异常，我们必须捕获它
//否则web套接字将保持打开状态。
e、 printStackTrace（）；
这个。关闭（）；
}
}
@凌驾
公共void onClose（int代码、字符串原因、布尔远程）{
试一试{
System.out.println（“Websocket关闭参数：“+”代码：“+code+”，“+”原因：“+reason+”，”
+“远程：”+远程）；
如果（代码！=1000）{
System.out.println（“Websocket未正常关闭”）；
}否则{
System.out.println（“订阅时Web套接字正常关闭”）；
}
}捕获（例外e）{
//System.out.println（“订阅的onClose回调中发生错误
//“+下标ID，e）；
e、 printStackTrace（）；
}
}
@凌驾
公共无效申报人（例外情况除外）{
例如printStackTrace（）；
}
}

所以，有谁能在这里帮助我，是什么原因导致无法连接

谢谢大家!