Java 创建要发送并等待响应的线程（WebSocket）

有一个方法连接到套接字并发送消息，然后休眠一秒钟以处理响应

import com.ning.http.client.AsyncHttpClient;
import com.ning.http.client.websocket.WebSocket;
import com.ning.http.client.websocket.WebSocketTextListener;
import com.ning.http.client.websocket.WebSocketUpgradeHandler;
import org.codehaus.jettison.json.JSONArray;
import org.codehaus.jettison.json.JSONObject;
import org.jboss.netty.handler.codec.http.HttpHeaders;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;


public class SocketClient implements WebSocketTextListener {

    private static org.slf4j.Logger log = LoggerFactory.getLogger(SocketClient.class);
    private WebSocket websocket;
    private List<String> serverResponse = new ArrayList<String>();
    private List<String> logFromResponse = new ArrayList<String>();

    public List<String> getAllLogs(String receiverId){
        logFromResponse = new ArrayList<String>();
        JSONObject jObj = new JSONObject();
        try {
            jObj.put("deviceId", receiverId);
        }catch(Exception e){
            log.warn("JSON Exception: "+e.getLocalizedMessage(), e);
        }
        connectToSocket();
        if (websocket!=null)
            websocket.sendTextMessage(jObj.toString());

        responseFromServer();

        return logFromResponse;
    }

    public boolean clearForDevice(String receiverId){
        JSONObject jObj = new JSONObject();
        try {
            jObj.put("deviceId", receiverId);
        }catch(Exception e){
            log.warn("JSON Exception: "+e.getLocalizedMessage(), e);
        }

        connectToSocket();
        if (websocket!=null)
            websocket.sendTextMessage(jObj.toString());

        String res = responseFromServer();
        return (res!=null) && res.contains("Success");
    }

    private void connectToSocket() {
        AsyncHttpClient c = new AsyncHttpClient();

        AsyncHttpClient.BoundRequestBuilder builder = c.prepareGet(createUri())
                .addHeader(HttpHeaders.Names.CONNECTION, "Upgrade")
                .addHeader(HttpHeaders.Names.UPGRADE, "WebSocket");

        websocket = builder.execute(new WebSocketUpgradeHandler.Builder()
                .addWebSocketListener(this).build()).get(); 
    }

    @Override
    public void onOpen(WebSocket webSocket) {
        log.debug("Opening WebSocket");
    }

    @Override
    public void onClose(WebSocket webSocket) {
        log.debug("Closing WebSocket");
    }

    @Override
    public void onError(Throwable throwable) { }

    @Override
    public void onMessage(String message) {
        serverResponse.add(message);
    }

    @Override
    public void onFragment(String s, boolean b) {    }

    private String responseFromServer() {
        String response = null;
        sleep(100);
        if (!serverResponse.isEmpty()) {
            //format message and send response and add to logFromResponse
        }
        return response;
    }

    protected void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            log.warn("Interrupted Exception: "+e.getLocalizedMessage(), e);
        }
    }
}

import com.ning.http.client.AsyncHttpClient；
导入com.ning.http.client.websocket.websocket；
导入com.ning.http.client.websocket.websocketextlistener；
导入com.ning.http.client.websocket.WebSocketUpgradeHandler；
导入org.codehaus.jettison.json.JSONArray；
导入org.codehaus.jettison.json.JSONObject；
导入org.jboss.netty.handler.codec.http.HttpHeaders；
导入org.json.simple.parser.JSONParser；
导入org.json.simple.parser.ParseException；
导入org.slf4j.LoggerFactory；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.ExecutionException；
公共类SocketClient实现WebSocketTextListener{
私有静态org.slf4j.Logger log=LoggerFactory.getLogger（SocketClient.class）；
私有WebSocket WebSocket；
private List serverResponse=new ArrayList（）；
private List logFromResponse=new ArrayList（）；
公共列表getAllLogs（字符串receiverId）{
logFromResponse=newArrayList（）；
JSONObject jObj=新的JSONObject（）；
试一试{
jObj.put（“设备ID”，接收方）；
}捕获（例外e）{
log.warn（“JSON异常：+e.getLocalizedMessage（），e）；
}
连接到插座（）；
如果（websocket！=null）
sendTextMessage（jObj.toString（））；
responseFromServer（）；
返回logFromResponse；
}
公共布尔clearForDevice（字符串接收方ID）{
JSONObject jObj=新的JSONObject（）；
试一试{
jObj.put（“设备ID”，接收方）；
}捕获（例外e）{
log.warn（“JSON异常：+e.getLocalizedMessage（），e）；
}
连接到插座（）；
如果（websocket！=null）
sendTextMessage（jObj.toString（））；
字符串res=responseFromServer（）；
返回（res！=null）和&res.contains（“成功”）；
}
私有void connectToSocket（）{
AsyncHttpClient c=新的AsyncHttpClient（）；
AsyncHttpClient.BoundRequestBuilder=c.prepareGet（createUri（））
.addHeader（HttpHeaders.Names.CONNECTION，“升级”）
.addHeader（HttpHeaders.Names.UPGRADE，“WebSocket”）；
websocket=builder.execute（新的WebSocketUpgradeHandler.builder（）
.addWebSocketListener（this.build（））.get（）；
}
@凌驾
公共空间打开（WebSocket WebSocket）{
调试（“打开WebSocket”）；
}
@凌驾
公共void onClose（WebSocket WebSocket）{
log.debug（“关闭WebSocket”）；
}
@凌驾
公共无效者（可抛弃者）{}
@凌驾
公共消息无效（字符串消息）{
serverResponse.add（消息）；
}
@凌驾
公共void onFragment（字符串s，布尔值b）{}
私有字符串responseFromServer（）{
字符串响应=null；
睡眠（100）；
如果（！serverResponse.isEmpty（））{
//格式化消息并发送响应并添加到logFromResponse
}
返回响应；
}
受保护的无效睡眠（长毫秒）{
试一试{
睡眠（毫秒）；
}捕捉（中断异常e）{
log.warn（“中断的异常：+e.getLocalizedMessage（），e）；
}
}
}

但是，我想在不使用sleep（）的情况下运行1秒，使用不阻塞io的AsyncHttpClient连接到套接字。我想创建一个线程，它可以发送消息并等待服务器的响应？我确实试图通过实现runnable接口来创建一个类，但没有成功！ 任何关于如何创建对WebSocket的同步调用或阻止IO的建议

---

更新：使用同步块等待，然后在收到消息后通知！直接从Ning主页跟随@Antoniosss评论

    import com.ning.http.client.*;
    import java.util.concurrent.Future;

    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    Future<Response> f = asyncHttpClient.prepareGet("http://www.ning.com/").execute(); //here you will execute async request
    Response r = f.get(); // here you will block until respons is accessible;

import com.ning.http.client.*；
导入java.util.concurrent.Future；
AsyncHttpClient AsyncHttpClient=新的AsyncHttpClient（）；
Future f=asyncHttpClient.prepareGet（“http://www.ning.com/execute（）//在这里，您将执行异步请求
响应r=f.get（）；//在这里，您将阻止，直到可以访问Response；

因此，我猜想

AsyncHttpClient

设计为

Sync

（如果需要），因为这段代码将阻塞并等待响应。当您在一段时间后调用

get（）

时，可能会立即访问响应，因为同时请求已经完成

---

现在在新线程中运行这两个部分，执行和响应reding，或者在主线程中执行请求，并在后台线程中等待响应（get（）部分）-瞧，你不能使用同步客户端而不是异步客户端，在另一个线程中发送/接收吗？不管怎样，

websocket

是什么？

responseFromServer（）

这到底是什么样的API，因为它不是

javax.websocket

as标记，它会提示我在哪里以及如何发送文本消息？