我为项目构建了一个简单的客户端和服务器，使用非常基本的文本界面进行测试和开发（代码演示如下）。
客户端库有一个acceptMessage（）方法和一个getMessage（）方法，它基本上将消息分别输入阻塞问题或从阻塞问题中拉出消息（在客户端中这是用put（）和take实现的（ ）电话）。一个线程在System.in上阻塞，并通过acceptMessage将读取行发送到客户端，而其他块在客户端getMessage（）方法上，并在它们到达时回显消息到System.out。所有非常基本但它的工作正常。
现在我已经让我的客户端库工作了，我正在试图弄清楚如何将它集成到使用Swing GUI的应用程序中。到目前为止，我还没有比在Netbeans中使用文本输入框和标签在界面构建工具中构建简单表单更进一步。我们的想法是让文本输入框取代从system.in和标签中读取的位置，以显示本来写入system.out的内容。到那时，我将在Swing中复制我的简单测试应用程序。
根据我的理解，与Swing GUI交互的所有内容都必须在Swing线程中运行，但客户端是作为自己的线程运行的。我不认为从GUI向acceptMessage（）发送消息将非常困难（我认为它涉及设置一个ActionPerformed方法，它将读取输入框的内容并在客户端调用acceptMessage（），尽管我'我还在试图解决这个问题，但我不知道如何回复。我知道由于线程安全问题，我无法在GUI线程中调用客户端调用功能，而且客户端库的编写方式是不知道它的消费类。客户端实例只是传递给使用者类，然后使用acceptMessage（）和getMessage（）来发送和接收消息。它不（也不应该）关心消费类实际上是什么。
这种架构是否可以轻松地将客户端集成到GUI中？如果是这样，从客户端处理输入的正确方法是什么？ （就像我说的，我认为一旦我弄清楚Swing的那个方面，输出到客户端并不会特别困难）。
我使用Swing的主要动机是：a）它似乎是用于Java的最佳文档GUI库，b）Netbeans已经拥有使用Swing的工具和c）我有一个严格的截止日期，没有时间切换GUI库并从头开始（这是针对大学项目）。如果我有更多的时间可能会看到其他图书馆，但我想他们都有自己的怪癖。
import java.io.*;
import java.util.logging.*;
public class TestApp implements Runnable {
private Client <String> client = null;
private UpstreamChannel upstream = null;
private DownstreamChannel downstream = null;
private Thread upstreamThread = null;
private Thread downstreamThread = null;
private boolean ending = false;
private class UpstreamChannel implements Runnable {
private TestApp outer = null;
@Override
public void run () {
Thread.currentThread ().setName ("TestApp.UpstreamChannel");
try (BufferedReader inReader = new BufferedReader (new InputStreamReader (System.in))) {
while (!this.outer.ending) {
this.outer.client.acceptMessage (inReader.readLine ());
}
} catch (IOException ex) {
Logger.getLogger (this.getClass ().getName ()).log (Level.SEVERE, ex.getMessage (), ex);
} finally {
this.outer.ending = true;
this.outer.downstreamThread.interrupt ();
Thread.currentThread ().interrupt ();
return;
}
}
public UpstreamChannel (TestApp app) {
this.outer = app;
}
}
private class DownstreamChannel implements Runnable {
private TestApp outer = null;
@Override
public void run () {
Thread.currentThread ().setName ("TestApp.DownstreamChannel");
try {
while (!this.outer.ending) {
System.out.println (this.outer.client.getMessage ());
}
} catch (InterruptedException ex) {
Logger.getLogger (this.getClass ().getName ()).log (Level.INFO, ex.getMessage (), ex);
} finally {
this.outer.ending = true;
this.outer.upstreamThread.interrupt ();
Thread.currentThread ().interrupt ();
return;
}
}
public DownstreamChannel (TestApp app) {
this.outer = app;
}
}
@Override
public void run () {
if ((null == this.upstreamThread)
&& (null == this.downstreamThread)) {
this.upstreamThread = new Thread (this.upstream);
this.downstreamThread = new Thread (this.downstream);
this.upstreamThread.start ();
this.downstreamThread.start ();
try {
this.upstreamThread.join ();
this.downstreamThread.join ();
} catch (InterruptedException ex) {
Logger.getLogger (this.getClass ().getName ()).log (Level.INFO, ex.getMessage (), ex);
} finally {
this.upstreamThread.interrupt ();
this.downstreamThread.interrupt ();
System.out.println ("Sayonara");
}
}
}
public TestApp (Client <String> client) {
this.upstream = new UpstreamChannel (this);
this.downstream = new DownstreamChannel (this);
this.client = client;
Logger.getLogger (this.getClass ().getName ()).log (Level.INFO, "Class instantiated");
}
}
启动客户端应用程序的代码如下：
public static void main (String[] args) throws UnknownHostException, IOException, InterruptedException {
Client <String> clientInstance = new Client ("localhost", 8113);
TestApp app = new TestApp (clientInstance);
Thread clientThread = new Thread (clientInstance);
Thread appThread = new Thread (app);
clientThread.start ();
appThread.start ();
clientThread.join ();
appThread.interrupt ();
System.exit (0);
}
}
SwingWorker reader = new SwingWorker () {
@Override
protected Object doInBackground () throws Exception {
while (!this.isCancelled ()) {
publish (clientInstance.getMessage ());
}
return null;
}
};
答案 0 :(得分：2)
所以你的基本问题是如何获得
while (!this.outer.ending) {
System.out.println (this.outer.client.getMessage ());
}
在标签上设置文本而不是打印到stdout。你是对的，因为这是一个单独的线程，你不能直接在GUI小部件上调用方法。但是你可以要求GUI线程调度一些将在GUI线程中运行的代码，
while (!this.outer.ending) {
final String message = this.outer.client.getMessage ();
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
theLabel.setText(message);
}
});
}
另一种方式可能就像在GUI调用中使用事件处理程序一样简单
this.outer.client.acceptMessage (textBox.getText());
但是如果acceptMessage也是一个阻塞调用，那么你也需要一个单独的线程，并让GUI将消息传递给该线程。
答案 1 :(得分：1)
我个人喜欢在你的actionPerformed方法中遵循这样的事情：
public void actionPerformed( ActionEvent event ) {
Promise<SomeReturn> promise = server.acceptMessage( message, SomeReturn.class );
promise.onSuccess( new Callback() {
public void call( SomeReturn result ) {
// this is on the swing thread
someLabel.setText( result.getText() );
}
});
}
然后这是异步操作的promise类：
public class Promise<T> {
Callback<T> successCallback;
Callback<? extends Exception> errorCallback;
// swing client will register callbacks with these methods
public onSuccess( Callback<T> callback ) {
successCallback = callback;
}
// swing client will register callbacks with these methods
public Promise<T> onError( Callback<? extends Exception> callback ) {
errorCallback = callback;
}
// network client thread will call these methods when it gets a response
public void setResult( final T result ) {
SwingUtilities.invokeLater( new Runnable() {
public void run() {
if( successCallback != null )
successCallback.call( result );
else
log.warning("Response dropped! No success callback registered " + result );
}
});
}
// network client thread will call these methods when it gets a response
public void setError( final Exception ex ) {
SwingUtilities.invokeLater( new Runnable() {
public void run() {
if( errorCallback != null )
errorCallback.call( ex );
else
log.error( ex );
}
});
}
}
我不喜欢使用类似getMessage（）的东西，因为这需要一个同步样式编码，其中swing客户端必须轮询或知道何时调用getMessage（）以便它不会阻塞线程。相反，为什么不让执行工作的线程在响应到达时调用您。它通过在它返回的Promise上调用setResult（）或setError（）来实现。您通过调用acceptMessage（）请求另一个线程执行操作，然后它返回给您一个Promise。您可以注册该承诺，以便在处理该消息时获得通知（成功或错误）。
在Java SE API中，我们拥有与Promise这个概念非常接近的Future，但不幸的是，它们没有提供回调机制，以便在结果到达时得到通知。 API作者没有这样做是非常令人失望的，因为他们创建的界面几乎没用。
在acceptMessage（）实现的后面可能有很多东西。您可以启动传递消息的线程并承诺为该消息提供服务，或者您可以将消息+ promise放到消费者线程或线程池从中抽取的队列中。当它完成对消息的处理时，它使用promise来回调你的UI。