[Java ] 通信

所谓可以多客户端，就是需要在服务器端进行多线程编程，每一个客户端对应一个线程。如果要实现时时通讯和话，无论是客户端还是服务器端都要至少两个线程，主线程进行发送信息，子线程进行获取信息，这样可以保证时时通信.

下面贴出我的代码：

客户端：

[java] view plaincopy

1. package com.lip;
2. import java.io.BufferedReader;
3. import java.io.BufferedWriter;
4. import java.io.IOException;
5. import java.io.InputStreamReader;
6. import java.io.OutputStreamWriter;
7. import java.io.PrintWriter;
8. import java.net.Socket;
9. import java.util.Scanner;
10. public class Client
11. {
12. /**
13. * Author: Lip
14. * 客户端
15. */
16. public static void main(String[] args)
17. {
18. Socket socket = null;
19. BufferedReader br = null;
20. PrintWriter pw = null;
21. Scanner scanner = new Scanner(System.in);// 从键盘读取
22. try
23. {
24. // 创建客户端socket
25. socket = new Socket(Server.HOST, Server.PORT);
26. // 读取从客户端发来的消息
27. br = new BufferedReader(new InputStreamReader(
28. socket.getInputStream()));
29. // 写入信息到服务器端
30. pw = new PrintWriter(
31. new BufferedWriter(new OutputStreamWriter(
32. socket.getOutputStream())));
33. new ReadServerMessage(br);// 从服务器读取消息
34. while (true)
35. {
36. String temp = scanner.nextLine();// 从键盘读取一行
37. pw.println(temp);// 写到服务器
38. pw.flush();
39. if (temp.equals("q"))
40. break;
41. }
42. }
43. catch (Exception e)
44. {
45. e.printStackTrace();
46. }
47. finally
48. {
49. try
50. {
51. System.out.println("close......");
52. br.close();
53. pw.close();
54. socket.close();
55. }
56. catch (IOException e)
57. {
58. e.printStackTrace();
59. }
60. }
61. }
62. }
63. class ReadServerMessage extends Thread//从服务器读取消息
64. {
65. BufferedReader bReader;
66. Socket socket;
67. public ReadServerMessage(BufferedReader br)
68. {
69. this.bReader = br;
70. start();
71. }
72. public void run()
73. {
74. String str = "";
75. while (true)//一直等待着服务器的消息
76. {
77. try
78. {
79. str = bReader.readLine();
80. if (str.equals("q"))
81. {
82. bReader.close();
83. socket.close();
84. break;
85. }
86. }
87. catch (IOException e)
88. {
89. e.printStackTrace();
90. }
91. System.out.println("Server Message:" + str);
92. }
93. }
94. }

服务器端：

[java] view plaincopy

1. package com.lip;
2. import java.io.IOException;
3. import java.net.ServerSocket;
4. import java.net.Socket;
5. public class Server
6. {
7. /**
8. * Author:Lip Desc:SSD8_exercise1
9. */
10. public static int PORT = 8000;
11. public static String HOST = "127.0.0.1";
12. public static void main(String[] args)
13. {
14. ServerSocket serverSocket = null;
15. Socket socket = null;
16. try
17. {
18. serverSocket = new ServerSocket(PORT);
19. // 等待请求,无请求一直等待
20. while (true)
21. {
22. System.out.println("Waiting Client");
23. socket = serverSocket.accept();// 接受请求
24. System.out.println("Client Conect!");
25. new ThreadedServer(socket);
26. }
27. }
28. catch (Exception e)
29. {
30. try
31. {
32. socket.close();
33. }
34. catch (IOException e1)
35. {
36. e1.printStackTrace();
37. }
38. }
39. finally
40. {
41. try
42. {
43. serverSocket.close();
44. }
45. catch (IOException e)
46. {
47. e.printStackTrace();
48. }
49. }
50. }
51. }

辅助线程：

[java] view plaincopy

1. package com.lip;
2. import java.io.BufferedReader;
3. import java.io.BufferedWriter;
4. import java.io.IOException;
5. import java.io.InputStreamReader;
6. import java.io.OutputStreamWriter;
7. import java.io.PrintWriter;
8. import java.net.Socket;
9. import java.util.Scanner;
10. public class ThreadedServer extends Thread
11. {
12. private Socket socket = null;
13. private BufferedReader br = null;
14. private PrintWriter pw = null;
15. private Scanner scanner = null;
16. public ThreadedServer(Socket s)
17. {
18. socket = s;
19. try
20. {
21. br = new BufferedReader(new InputStreamReader(
22. socket.getInputStream()));
23. pw = new PrintWriter(
24. new BufferedWriter(new OutputStreamWriter(
25. socket.getOutputStream())), true);
26. scanner = new Scanner(System.in);// 从键盘读取数据
27. start();
28. }
29. catch (Exception e)
30. {
31. e.printStackTrace();
32. }
33. }
34. public void run()
35. {
36. new ReadClientMessage(br, socket);//读取客户端数据
37. while (true)//向客户端发送数据
38. {
39. try
40. {
41. pw.println(scanner.nextLine());
42. pw.flush();
43. }
44. catch (Exception e)
45. {
46. try
47. {
48. br.close();
49. pw.close();
50. socket.close();
51. }
52. catch (IOException e1)
53. {
54. e1.printStackTrace();
55. }
56. }
57. }
58. }
59. }
60. class ReadClientMessage extends Thread
61. {
62. BufferedReader bReader;
63. Socket socket;
64. public ReadClientMessage(BufferedReader br,Socket s)
65. {
66. this.bReader = br;
67. this.socket=s;
68. start();
69. }
70. public void run()
71. {
72. String str = "";
73. while (true)
74. {
75. try
76. {
77. str = bReader.readLine();
78. if (str.equals("q"))
79. {
80. bReader.close();
81. socket.close();
82. break;
83. }
84. }
85. catch (IOException e)
86. {
87. e.printStackTrace();
88. }
89. System.out.println("Client Message:" + str);
90. }
91. }
92. }

现在就可以实现多客户端和服务器端通信了 ，不过客户端和客户端的通信暂时还没有搞懂，还要继续去学习