首页 > 编程语言 > 详细

[Java ] 通信

时间：2015-08-20 18:38:46      阅读：225      评论：0      收藏：0      [点我收藏+]

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

 

下面贴出我的代码：

客户端：

 

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


服务器端：

 

 

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


辅助线程：

 

 

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


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

[Java ] 通信

原文：http://www.cnblogs.com/feifeidxl/p/4745850.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！