如何在多线程聊天客户端中为客户端分配用户名

huangapple
go评论103阅读模式
英文:

How to give a username to clients in a multi-threaded chat client

问题

My Problem: 当前，我不明白如何为我的聊天客户端分配每个客户端的用户名。因此，我的输出只是："A user says: [用户的聊天内容]"

My Code:

Client.java（自说明）

  1. package chatroom;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.net.UnknownHostException;
  9. import java.util.Scanner;
  11. public class Client {
  13.     public static void main(String[] args) {
  14.         Client client = new Client("localhost", 9090);
  15.     }
  17.     private Socket clientConnection;
  18.     private PrintWriter sender;
  19.     private BufferedReader receiver;
  20.     private Scanner scan = new Scanner(System.in);
  21.     private String request;
  22.     public static boolean firstMessage = true;
  24.     public Client(String serverip, int port) {
  26.         try {
  27.             clientConnection = new Socket(serverip, port);
  28.             sender = new PrintWriter(clientConnection.getOutputStream(), true);
  29.             receiver = new BufferedReader(new InputStreamReader(clientConnection.getInputStream()));
  31.         } catch (UnknownHostException e) {
  32.             e.printStackTrace();
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }
  37.         new Thread(new ChatHandler(clientConnection)).start();
  39.         while (true) {
  40.             if (request != null) {
  42.             } else {
  43.                 System.out.println("欢迎来到聊天室！开始聊天吧！");
  44.             }
  45.                 request = scan.nextLine();
  46.                 sender.println(request);
  47.             if (request.equals("quit")) {
  48.                 System.exit(0);
  49.                 break;
  50.             }
  51.         }
  52.     }
  53. }

Server.java（自说明）

  1. package chatroom;
  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6. import java.util.ArrayList;
  8. public class Server {
  10.     public static void main(String[] args) {
  11.         Server server = new Server(9090);
  12.     }
  14.     private ServerSocket serverSocket;
  15.     private Socket clientConnection;
  16.     private ArrayList<ClientHandler> clients = new ArrayList<ClientHandler>();
  18.     public Server(int port) {
  19.         try {
  20.             serverSocket = new ServerSocket(port);
  21.         } catch (IOException e1) {
  22.             e1.printStackTrace();
  23.         }
  25.         while (true) {
  26.             System.out.println("[SERVER] 等待客户端连接...");
  27.             try {
  28.                 clientConnection = serverSocket.accept();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.             System.out.println("[SERVER] 客户端连接成功！");
  33.             ClientHandler clientThread = new ClientHandler(clientConnection, clients);
  34.             clients.add(clientThread);
  35.             Thread t = new Thread(clientThread);
  36.             t.start();
  37.         }
  38.     }
  39. }

ClientHandler.java（从用户接收输入并发送回客户端的可运行程序）

  1. package chatroom;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.util.ArrayList;
  10. public class ClientHandler implements Runnable {
  12.     private Socket clientConnection;
  13.     private BufferedReader receiver;
  14.     private PrintWriter sender;
  15.     private String clientRequest, clientUsername;
  16.     private ArrayList<ClientHandler> clients;
  18.     public ClientHandler(Socket clientConnection, ArrayList<ClientHandler> clients) {
  19.         this.clientConnection = clientConnection;
  20.         this.clients = clients;
  22.         try {
  23.             receiver = new BufferedReader(new InputStreamReader(clientConnection.getInputStream()));
  24.             sender = new PrintWriter(clientConnection.getOutputStream(), true);
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  30.     @Override
  31.     public void run() {
  32.         try {
  33.             while (true) {
  34.                 String userInput = receiver.readLine();
  35.                 if (userInput.equals("quit")) {
  36.                     System.out.println("[SERVER] 收到强制用户关闭输入。现在退出...");
  37.                     System.exit(0);
  38.                     break;
  39.                 }
  41.                 System.out.println("[SERVER] 收到用户输入...");
  43.                 sender = new PrintWriter(clientConnection.getOutputStream(), true);
  44.                 System.out.println("[SERVER] 正在尝试将消息发送给其他客户端...");
  46.                 for (ClientHandler aClient : clients) {
  48.                     String serverResponse = "一个用户说：" + userInput;
  49.                     aClient.sender.println(serverResponse);
  51.                 }
  52.             }
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.         }
  56.     }
  57. }

ChatHandler.java（向客户端输出聊天内容，允许客户端在产生输出时进行输入）

  1. package chatroom;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.net.Socket;
  8. public class ChatHandler implements Runnable {
  10.     private Socket clientConnection;
  11.     private BufferedReader receiver;
  13.     public ChatHandler(Socket clientConnection) {
  14.         this.clientConnection = clientConnection;
  15.         try {
  16.             receiver = new BufferedReader(new InputStreamReader(clientConnection.getInputStream()));
  17.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  22.     @Override
  23.     public void run() {
  24.         try {
  25.             while (true) {
  26.                 String serverResponse = receiver.readLine();
  28.                 if (serverResponse == null) {
  29.                     break;
  30.                 }
  32.                 System.out.println("\n" + serverResponse);
  33.             }
  34.         } catch (IOException e) {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38. }
英文:

My Problem: Currently, I do not understand how to assign each Client a username for my chat client. Therefore, I just have the output as: "A user says: [user's chat]"

My Code:

Client.java (Self Explanatory)

  1. package chatroom;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.PrintWriter;
  6. import java.net.Socket;
  7. import java.net.UnknownHostException;
  8. import java.util.Scanner;
  9. public class Client {
  10. public static void main(String[] args) {
  11. Client client = new Client(&quot;localhost&quot;, 9090);
  12. }
  13. private Socket clientConnection;
  14. private PrintWriter sender;
  15. private BufferedReader receiver;
  16. private Scanner scan = new Scanner(System.in);
  17. private String request;
  18. public static boolean firstMessage = true;
  19. public Client(String serverip, int port) {
  20. try {
  21. clientConnection = new Socket(serverip, port);
  22. sender = new PrintWriter(clientConnection.getOutputStream(), true);
  23. receiver = new BufferedReader(new InputStreamReader(clientConnection.getInputStream()));
  24. } catch (UnknownHostException e) {
  25. // TODO Auto-generated catch block
  26. e.printStackTrace();
  27. } catch (IOException e) {
  28. // TODO Auto-generated catch block
  29. e.printStackTrace();
  30. }
  31. new Thread(new ChatHandler(clientConnection)).start();
  32. while (true) {
  33. if (request != null) {
  34. } else {
  35. System.out.println(&quot;Welcome to the ChatRoom! Type to get started!&quot;);
  36. }
  37. request = scan.nextLine();
  38. sender.println(request);
  39. if (request.equals(&quot;quit&quot;)) {
  40. System.exit(0);
  41. break;
  42. }
  43. }
  44. }
  45. }

Server.java (Self Explanatory)

  1. package chatroom;
  2. import java.io.IOException;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  5. import java.util.ArrayList;
  6. public class Server {
  7. public static void main(String[] args) {
  8. Server server = new Server(9090);
  9. }
  10. private ServerSocket serverSocket;
  11. private Socket clientConnection;
  12. private ArrayList&lt;ClientHandler&gt; clients = new ArrayList&lt;ClientHandler&gt;();
  13. public Server(int port) {
  14. try {
  15. serverSocket = new ServerSocket(port);
  16. } catch (IOException e1) {
  17. // TODO Auto-generated catch block
  18. e1.printStackTrace();
  19. }
  20. while (true) {
  21. System.out.println(&quot;[SERVER] Waiting for Client Connection...&quot;);
  22. try {
  23. clientConnection = serverSocket.accept();
  24. } catch (IOException e) {
  25. // TODO Auto-generated catch block
  26. e.printStackTrace();
  27. }
  28. System.out.println(&quot;[SERVER] Client Connected Successfully!&quot;);
  29. ClientHandler clientThread = new ClientHandler(clientConnection, clients);
  30. clients.add(clientThread);
  31. Thread t = new Thread(clientThread);
  32. t.start();
  33. }
  34. }
  35. }

ClientHandler.java (Runnable that receieves input from user and sends it back to clients)

  1. package chatroom;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.PrintWriter;
  6. import java.net.Socket;
  7. import java.util.ArrayList;
  8. public class ClientHandler implements Runnable {
  9. private Socket clientConnection;
  10. private BufferedReader receiver;
  11. private PrintWriter sender;
  12. private String clientRequest, clientUsername;
  13. private ArrayList&lt;ClientHandler&gt; clients;
  14. public ClientHandler(Socket clientConnection, ArrayList&lt;ClientHandler&gt; clients) {
  15. this.clientConnection = clientConnection;
  16. this.clients = clients;
  17. try {
  18. receiver = new BufferedReader(new InputStreamReader(clientConnection.getInputStream()));
  19. sender = new PrintWriter(clientConnection.getOutputStream(), true);
  20. } catch (IOException e) {
  21. // TODO Auto-generated catch block
  22. e.printStackTrace();
  23. }
  24. }
  25. @Override
  26. public void run() {
  27. try {
  28. while (true) {
  29. String userInput = receiver.readLine();
  30. if (userInput.equals(&quot;quit&quot;)) {
  31. System.out.println(&quot;[SERVER] Received Forced User Shutdown Input. Now Exiting...&quot;);
  32. System.exit(0);
  33. break;
  34. }
  35. System.out.println(&quot;[SERVER] Received User Input... &quot;);
  36. sender = new PrintWriter(clientConnection.getOutputStream(), true);
  37. System.out.println(&quot;[SERVER] Attempting to Send the Message to the Other Clients...&quot;);
  38. for (ClientHandler aClient : clients) {
  39. String serverResponse = &quot;A user says: &quot; + userInput;
  40. aClient.sender.println(serverResponse);
  41. }
  42. }
  43. } catch (IOException e) {
  44. // TODO Auto-generated catch block
  45. e.printStackTrace();
  46. } 
  47. }
  48. }

ChatHandler.java (Runnable that outputs the chat to the client which allows the client to type while output is being produced)

  1. package chatroom;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.net.Socket;
  6. public class ChatHandler implements Runnable{
  7. private Socket clientConnection;
  8. private BufferedReader receiver;
  9. public ChatHandler(Socket clientConnection) {
  10. this.clientConnection = clientConnection;
  11. try {
  12. receiver = new BufferedReader(new InputStreamReader(clientConnection.getInputStream()));
  13. } catch (IOException e) {
  14. // TODO Auto-generated catch block
  15. e.printStackTrace();
  16. }
  17. }
  18. @Override
  19. public void run() {
  20. try {
  21. while(true) {
  22. String serverResponse = receiver.readLine();
  23. if(serverResponse == null) {
  24. break;
  25. }
  26. System.out.println(&quot;\n&quot; + serverResponse);
  27. }
  28. } catch (IOException e) {
  29. // TODO Auto-generated catch block
  30. e.printStackTrace();
  31. }
  32. }
  33. }

Any help is appreciated! Thank you all so much!
~AbysssCoder

答案1

得分: 1

以下是翻译好的代码部分：

  1. 发送文本和用户名的一种方法是创建一个新的对象
  3. 可以像这样：
  5. public class Message() implements Serializable {
  6.      public String message_, username;
  7.      private static final long serialVersionUID = 1L;
  9.      public Message(String message, String Username){
  10.          this.message_ = message;
  11.          this.username = Username;
  12.      }
  13. }
  15. 然后，不使用普通的 DataInputStream，而是使用 ObjectInputStream 来发送对象。
  16. 像这样：
  18. DataInputStream in = new DataInputStram(socket.getInputStream);
  19. ObjectInputStream input = new ObjectInputSream(in);
  21. Message message = (Message) input.readObject;
  22. System.out.println("From: " + message.username + ": " + message.message_);
  24. 并且你还必须使用 ObjectOutputStream，我建议你研究一下如何通过套接字发送对象。
英文:

A way that you can send the text and username is creating a new Object

It can be something like this:

  1. public class Message() implements Serializable {
  2. public String message_, username;
  3. private static final long serialVersionUID = 1L;
  4. public Message(String message, String Username){
  5. this.message_ = message;
  6. this.username = Username
  7. }
  8. }

Then instead of using the normal DataInputStream you use ObjectInputStream to send the object.
like this

  1.   DataInputStream in = new DataInputStram(socket.getInputStream);
  2. ObjectInputStream input = new ObjectInputSream(in);
  3. Message message = (Message) input.readObject;
  4. System.out.println(&quot;From: &quot; + message.username + &quot;: &quot; + message.message_)

And you also have to use ObjectOutputStream y recomend you to investigate about sending objects trhough sockets

huangapple
  • 本文由 发表于 2020年10月13日 11:11:11
  • 转载请务必保留本文链接：https://go.coder-hub.com/64327923.html
  • arraylist
  • chat
  • java
  • networking
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定