Java 如何等待SpringWebSocketStompClient连接

我正在使用实现一个简单的Stomp客户端：

WebSocketClient webSocketClient = new StandardWebSocketClient();
WebSocketStompClient stompClient = new WebSocketStompClient(webSocketClient);

ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
taskScheduler.afterPropertiesSet();
stompClient.setTaskScheduler(taskScheduler); // for heartbeats

stompClient.setMessageConverter(new StringMessageConverter());

StompSessionHandler sessionHandler = new MySessionHandler();
stompClient.connect("ws://server/endpoint", sessionHandler);

// WAITING HERE

连接完成后，它应该异步报告给

MySessionHandler

：

public class MySessionHandler extends StompSessionHandlerAdapter
{
     @Override
     public void afterConnected(StompSession session, StompHeaders connectedHeaders) 
     {
         // WAITING FOR THIS
     }
}

所以问题是：在这里等待的

行应该如何等待
行等待这个
？有没有一种特殊的Spring方法可以做到这一点？如果不是，哪种通用Java方式最适合这里？
也许a可以像这样解决您的问题：

CountDownLatch latch = new CountDownLatch(1);
StompSessionHandler sessionHandler = new MySessionHandler(latch);
stompClient.connect("ws://server/endpoint", sessionHandler);
// wait here till latch will be zero
latch.await();

ListenableFuture<StompSession> future = 
                 stompClient.connect("ws://server/endpoint", sessionHandler);
StompSession session = future.get(); // <--- this line will wait just like afterConnected()

以及您的
MySessionHandler
实现：

public class MySessionHandler extends StompSessionHandlerAdapter {
    private final CountDownLatch latch;

    public MySessionHandler(final CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void afterConnected(StompSession session, 
                               StompHeaders connectedHeaders) {
        try {
            // do here some job
        } finally {
            latch.countDown();
        }
    }
}

使用闩锁的解决方案有效。后来我发现
connect
函数返回
ListenableFuture
，所以我们可以像这样等待会话的创建：

CountDownLatch latch = new CountDownLatch(1);
StompSessionHandler sessionHandler = new MySessionHandler(latch);
stompClient.connect("ws://server/endpoint", sessionHandler);
// wait here till latch will be zero
latch.await();

ListenableFuture<StompSession> future = 
                 stompClient.connect("ws://server/endpoint", sessionHandler);
StompSession session = future.get(); // <--- this line will wait just like afterConnected()

ListenableFuture未来=
connect（“ws://server/endpoint”，sessionHandler）；
StompSession session=future.get（）；// 您不需要闩锁，什么都不需要，只有在建立连接时才会执行afterConnected方法

我的例子是：

URI stompUrlEndpoint = new URI("localhost:8080/Serv/enpoint");

ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
//Calls initialize() after the container applied all property values.
taskScheduler.afterPropertiesSet();

StandardWebSocketClient webSocketClient = new StandardWebSocketClient();
List<Transport> transports = new ArrayList<>(2);

transports.add(new WebSocketTransport(webSocketClient));

SockJsClient sockJsClient = new SockJsClient(transports);   

WebSocketStompClient stompClient = new WebSocketStompClient(sockJsClient);

stompClient.setMessageConverter(new SimpleMessageConverter());          // default converter: SimpleMessageConverter

// Configure a scheduler to use for heartbeats and for receipt tracking. 
stompClient.setTaskScheduler(taskScheduler);

StompSessionHandlerImp stompSessionHandlerImp = new StompSessionHandlerImp();

ListenableFuture<StompSession> stompSessionFuture2 = stompClient.connect(stompUrlEndpoint.toString(), stompSessionHandlerImp);


try {
            stompSession = stompSessionFuture.get(10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (TimeoutException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


       private class StompSessionHandlerImp extends StompSessionHandlerAdapter {
           private StompSession session;


          @Override
          public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
          this.session =  session;

          session.setAutoReceipt(true);
          session.subscribe("/user/queue/bancaria.readcard", new StompFrameHandler() {
            ...
       }
 }

uristompurlenpoint=newuri（“localhost:8080/Serv/enpoint”）；
ThreadPoolTaskScheduler taskScheduler=新的ThreadPoolTaskScheduler（）；
//在容器应用所有属性值后调用initialize（）。
taskScheduler.AfterPropertieSet（）；
StandardWebSocketClient webSocketClient=新的StandardWebSocketClient（）；
列表传输=新的ArrayList（2）；
添加（新的WebSocketTransport（webSocketClient））；
SockJsClient SockJsClient=新的SockJsClient（传输）；
WebSocketStompClient stompClient=新的WebSocketStompClient（sockJsClient）；
stompClient.setMessageConverter（新的SimpleMessageConverter（））；//默认转换器：SimpleMessageConverter
//配置用于心跳和收据跟踪的计划程序。
setTaskScheduler（taskScheduler）；
StompSessionHandlerImp StompSessionHandlerImp=新的StompSessionHandlerImp（）；
ListenableFuture stompSessionFuture2=stompClient.connect（stompurleendpoint.toString（），stompSessionHandlerImp）；
试一试{
stompSession=stompSessionFuture.get（10，时间单位为秒）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（执行例外）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（超时异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
私有类StompSessionHandlerImp扩展了StompSessionHandlerAdapter{
非公开StompSession；
@凌驾
连接后公用无效（StompSession会话，StompHeaders connectedHeaders）{
this.session=会话；
session.setAutoReceipt（真）；
session.subscribe（“/user/queue/bancaria.readcard”），新的StompFrameHandler（）{
...
}
}

}
future.get（）将为您提供会话对象，您应该从afterConnect获取该对象。。