我创建了（通过从互联网收集一些代码片段）基于控制台的LAN聊天应用程序。现在我想
使用Netbeans IDE 7.1制作GUI。 它是一个多线程应用程序。 在我的基于控制台的应用程序中，每当我想显示输出时，我都会通过
来完成System.out.println(msg) .
现在我想在JFrame表单中完成，
jTextField1.setText(msg).
我是否需要创建一个新的主类并创建一个JFrameForm实例并通过调用使其可见
new NewJFrame().setVisible(true);
或者我应该在JFrame类本身进行所有编码。我在我的实际和工作代码下面（在控制台中）
import java.io.DataInputStream;
import java.io.PrintStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
public class MultiThreadChatClient implements Runnable {
// The client socket
private static Socket clientSocket = null;
// The output stream
private static PrintStream os = null;
// The input stream
private static DataInputStream is = null;
private static BufferedReader inputLine = null;
private static boolean closed = false;
public static void main(String[] args) {
// The default port.
int portNumber = 2222;
// The default host.
String host = "127.0.0.1";
if (args.length < 2) {
System.out
.println("Usage: java MultiThreadChatClient <host> <portNumber>\n"
+ "Now using host=" + host + ", portNumber=" + portNumber);
} else {
host = args[0];
portNumber = Integer.valueOf(args[1]).intValue();
}
/*
* Open a socket on a given host and port. Open input and output streams.
*/
try {
clientSocket = new Socket(host, portNumber);
inputLine = new BufferedReader(new InputStreamReader(System.in));
os = new PrintStream(clientSocket.getOutputStream());
is = new DataInputStream(clientSocket.getInputStream());
} catch (UnknownHostException e) {
System.err.println("Don't know about host " + host);
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to the host "
+ host);
}
/*
* If everything has been initialized then we want to write some data to the
* socket we have opened a connection to on the port portNumber.
*/
if (clientSocket != null && os != null && is != null) {
try {
/* Create a thread to read from the server. */
new Thread(new MultiThreadChatClient()).start();
while (!closed) {
os.println(inputLine.readLine().trim());
}
/*
* Close the output stream, close the input stream, close the socket.
*/
os.close();
is.close();
clientSocket.close();
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
/*
* Create a thread to read from the server. (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
/*
* Keep on reading from the socket till we receive "Bye" from the
* server. Once we received that then we want to break.
*/
String responseLine;
try {
while ((responseLine = is.readLine()) != null) {
System.out.println(responseLine);
if (responseLine.indexOf("*** Bye") != -1)
break;
}
closed = true;
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
//MultiThreadServer.java
import java.io.DataInputStream;
import java.io.PrintStream;
import java.io.IOException;
import java.net.Socket;
import java.net.ServerSocket;
/*
* A chat server that delivers public and private messages.
*/
public class MultiThreadChatServer {
// The server socket.
private static ServerSocket serverSocket = null;
// The client socket.
private static Socket clientSocket = null;
// This chat server can accept up to maxClientsCount clients' connections.
private static final int maxClientsCount = 10;
private static final clientThread[] threads = new clientThread[maxClientsCount];
public static void main(String args[]) {
// The default port number.
int portNumber = 2222;
if (args.length < 1) {
System.out
.println("Usage: java MultiThreadChatServer <portNumber>\n"
+ "Now using port number=" + portNumber);
} else {
portNumber = Integer.valueOf(args[0]).intValue();
}
/*
* Open a server socket on the portNumber (default 2222). Note that we can
* not choose a port less than 1023 if we are not privileged users (root).
*/
try {
serverSocket = new ServerSocket(portNumber);
} catch (IOException e) {
System.out.println(e);
}
/*
* Create a client socket for each connection and pass it to a new client
* thread.
*/
while (true) {
try {
clientSocket = serverSocket.accept();
int i = 0;
for (i = 0; i < maxClientsCount; i++) {
if (threads[i] == null) {
(threads[i] = new clientThread(clientSocket, threads)).start();
break;
}
}
if (i == maxClientsCount) {
PrintStream os = new PrintStream(clientSocket.getOutputStream());
os.println("Server too busy. Try later.");
os.close();
clientSocket.close();
}
} catch (IOException e) {
System.out.println(e);
}
}
}
}
//ChatClient.java
/*
* The chat client thread. This client thread opens the input and the output
* streams for a particular client, ask the client's name, informs all the
* clients connected to the server about the fact that a new client has joined
* the chat room, and as long as it receive data, echos that data back to all
* other clients. When a client leaves the chat room this thread informs also
* all the clients about that and terminates.
*/
class clientThread extends Thread {
private DataInputStream is = null;
private PrintStream os = null;
private Socket clientSocket = null;
private final clientThread[] threads;
private int maxClientsCount;
public clientThread(Socket clientSocket, clientThread[] threads) {
this.clientSocket = clientSocket;
this.threads = threads;
maxClientsCount = threads.length;
}
public void run() {
int maxClientsCount = this.maxClientsCount;
clientThread[] threads = this.threads;
try {
/*
* Create input and output streams for this client.
*/
is = new DataInputStream(clientSocket.getInputStream());
os = new PrintStream(clientSocket.getOutputStream());
os.println("Enter your name.");
String name = is.readLine().trim();
os.println("Hello " + name
+ " to our chat room.\nTo leave enter /quit in a new line");
for (int i = 0; i < maxClientsCount; i++) {
if (threads[i] != null && threads[i] != this) {
threads[i].os.println("*** A new user " + name
+ " entered the chat room !!! ***");
}
}
while (true) {
String line = is.readLine();
if (line.startsWith("/quit")) {
break;
}
for (int i = 0; i < maxClientsCount; i++) {
if (threads[i] != null) {
threads[i].os.println("<" + name + "&gr; " + line);
}
}
}
for (int i = 0; i < maxClientsCount; i++) {
if (threads[i] != null && threads[i] != this) {
threads[i].os.println("*** The user " + name
+ " is leaving the chat room !!! ***");
}
}
os.println("*** Bye " + name + " ***");
/*
* Clean up. Set the current thread variable to null so that a new client
* could be accepted by the server.
*/
for (int i = 0; i < maxClientsCount; i++) {
if (threads[i] == this) {
threads[i] = null;
}
}
/*
* Close the output stream, close the input stream, close the socket.
*/
is.close();
os.close();
clientSocket.close();
} catch (IOException e) {
}
}
答案 0 :(得分：2)
虽然严格地说不是原始问题的一部分，但控制台应用程序和GUI应用程序之间存在许多非常重要的差异。
首先，线程模型是不同的，并且非常重要，您需要花时间了解使用它的内容和位置以及如何使用它。
首先，不要在Event Dispatching Thread（又称为EDT）（主要UI线程）中做任何阻止它的事情，例如，IO操作......如果可能的话，在另一个帖子中的背景或worker。
请勿从EDT以外的任何线程更新UI组件。 SwingWorker可以在某些情况下提供帮助，当您无法依赖SwingUtilities.invokeLater/invokeAndWait时
答案 1 :(得分：0)
我假设Netbeans IDE开发应用程序而不使用Netbeans平台。有一篇关于构建聊天客户端的DZone博客文章。我想你需要根据你的问题阅读。这篇博文使用AWT，但它是一个很好的开始。
答案 2 :(得分：0)
Java是一种面向对象的语言，所以我认为你应该创建一个像ChatFrame这样的类，这个ChatFrame类应该扩展 JFrame类。 （或者可以有一个JFrame实例，用于像“showChatFrame”这样的方法，对于Hovercraft Full Of Eels来说，这一点！）
因此，您可以在此ChatFrame类中编写每个gui代码，并在另一个类中执行服务器通信代码。
使用强大的模块是一种很好的编码风格。您的软件应该是几个通过接口之间进行通信的模块（不是每次都是真正的Java接口）。
您的主类应该只包含main方法，并为示例创建一个ServerCommunication对象，它执行通信并使用ChatFrame类向用户显示消息。