Java中Socket通信图解法（二）

步步测试完善Java中Socket通信图解法（二）

---

简介

Java中Socket通信简介

单线程一对一服务器1——>1客户端

单线程一对一服务器1<——>1客户端

多线程一对多服务器1<——>N客户端【非聊天室的服务器通过用户输入发送数据】

多线程一对多服务器1<——>N客户端【聊天室】

多线程最终服务器和客户端集成一体【swing程序】

---

  Java中Tcp协议Socket通信测试步骤：  【单线程】一对一服务器1——>1客户端     介绍：当客户端连接后，服务器会发送消息到客户端。客户端收到服务器发送来的消息，并输出。     代码如下：客户端和服务器端都在本机上测试。     服务器 [html] view plain copy print ?

1. package com17;  

2. import java.io.IOException;  

3. import java.io.PrintStream;  

4. import java.net.ServerSocket;  

5. import java.net.Socket;  

6. 
   

7. public class Server {  

8.     public static void main(String[] args) {  

9.          //创建月hi个ServerSocket，用于监听客户端Socket的连接请求  

10.          try {  

11.               ServerSocket ss=new ServerSocket(30000);  

12.               //采用死循环不断接受来自客户端的请求  

13.               while(true)  

14.               {  

15.                    //每当接受到客户端socket的请求，服务端也对应产生一个socket  

16.                    Socket s=ss.accept();  

17.                    System.out.println("IP为"+s.getInetAddress()+"连接此服务器");  

18.                    //将Socket对应的输出流包装成PrintStream  

19.                    PrintStream ps=new PrintStream(s.getOutputStream());  

20.                    //进行普通的io操作  

21.                    ps.println("客户端您好，我是服务器。");  

22.                    ps.close();  

23.                    s.close();          

24.               }  

25.          } catch (IOException e) {  

26.               // TODO Auto-generated catch block  

27.               e.printStackTrace();  

28.          }  

29. 
    

30.     }  

31. 
    

32. }  

package com17;import java.io.IOException;import java.io.PrintStream;import java.net.ServerSocket;import java.net.Socket;public class Server {     public static void main(String[] args) {          //创建月hi个ServerSocket，用于监听客户端Socket的连接请求          try {               ServerSocket ss=new ServerSocket(30000);               //采用死循环不断接受来自客户端的请求               while(true)               {                    //每当接受到客户端socket的请求，服务端也对应产生一个socket                    Socket s=ss.accept();                    System.out.println("IP为"+s.getInetAddress()+"连接此服务器");                    //将Socket对应的输出流包装成PrintStream                    PrintStream ps=new PrintStream(s.getOutputStream());                    //进行普通的io操作                    ps.println("客户端您好，我是服务器。");                    ps.close();                    s.close();                        }          } catch (IOException e) {               // TODO Auto-generated catch block               e.printStackTrace();          }              }}

  客户端： [html] view plain copy print ?

1. package com17;  

2. import java.io.BufferedReader;  

3. import java.io.IOException;  

4. import java.io.InputStreamReader;  

5. import java.net.Socket;  

6. 
   

7. public class Client {  

8.     public static void main(String[] args) {  

9.          try  

10.          {  

11.               Socket socket=new Socket("127.0.0.1",30000);  

12.               //将socket对应的输入流包装成BufferedReader  

13.               BufferedReader br=new BufferedReader( new InputStreamReader(socket.getInputStream()));  

14. 
    

15.               //进行普通的io操作  

16.               String line=br.readLine();  

17.               System.out.println("来自服务器的数据：："+line);  

18.               br.close();  

19.               socket.close();  

20. 
    

21.          }  

22.          catch(IOException e)  

23.          {  

24.               e.printStackTrace();  

25.          }  

26. 
    

27.     }  

28. 
    

29. }  

package com17;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.net.Socket;public class Client {     public static void main(String[] args) {          try          {               Socket socket=new Socket("127.0.0.1",30000);               //将socket对应的输入流包装成BufferedReader               BufferedReader br=new BufferedReader( new InputStreamReader(socket.getInputStream()));                             //进行普通的io操作               String line=br.readLine();               System.out.println("来自服务器的数据：："+line);               br.close();               socket.close();          }          catch(IOException e)          {               e.printStackTrace();          }              }}

 效果如下： 【单线程】一对一服务器1<——>1客户端      介绍：服务器和客户端分别接受对方发送的信息，然后再发送数据到对方。      若是发送已经编译好的数据，则这块是很简单的。      在第一个demo的基础上，修改服务器端的main方法：      服务器端： [html] view plain copy print ?

1. while( true)  

2. 
   

3.    //每当接受到客户端socket的请求，服务端也对应产生一个socket  

4.   Socket s=ss.accept();  

5.   System. out.println( "IP为"+s.getInetAddress()+ "连接此服务器" );  

6.    //接受客户端发送的数据  

7.   BufferedReader br= new BufferedReader( new InputStreamReader(s.getInputStream()));  

8.   System. out.println( "来自客户端的数据：" +br.readLine());  

9.    //将Socket对应的输出流包装成PrintStream  

10.   PrintStream ps= new PrintStream(s.getOutputStream());  

11.    //进行普通的 io操作  

12.   ps.println( "客户端您好，我是服务器。" );  

13.   ps.close();  

14.   br.close();  

15.   s.close();        

                  while( true)                {                      //每当接受到客户端socket的请求，服务端也对应产生一个socket                     Socket s=ss.accept();                     System. out.println( "IP为"+s.getInetAddress()+ "连接此服务器" );                      //接受客户端发送的数据                     BufferedReader br= new BufferedReader( new InputStreamReader(s.getInputStream()));                     System. out.println( "来自客户端的数据：" +br.readLine());                      //将Socket对应的输出流包装成PrintStream                     PrintStream ps= new PrintStream(s.getOutputStream());                      //进行普通的 io操作                     ps.println( "客户端您好，我是服务器。" );                     ps.close();                     br.close();                     s.close();                      }

 客户端： [html] view plain copy print ?

1. try  

2. {  

3.     Socket socket=new Socket("127.0.0.1",30000);  

4.      //发送数据  

5.     PrintStream ps= new PrintStream(socket.getOutputStream());  

6.     ps.println( "您好，我是客户端" );  

7.      //将socket对应的输入流包装成BufferedReader  

8.     BufferedReader br= new BufferedReader( new InputStreamReader(socket.getInputStream()));  

9.      //进行普通的io操作  

10.     String line=br.readLine();  

11.     System. out.println( "来自服务器的数据：：" +line);  

12.     br.close();  

13.     ps.close();  

14.      socket.close();  

15. 
    

16. }  

            try           {                Socket socket=new Socket("127.0.0.1",30000);                 //发送数据                PrintStream ps= new PrintStream(socket.getOutputStream());                ps.println( "您好，我是客户端" );                 //将socket对应的输入流包装成BufferedReader                BufferedReader br= new BufferedReader( new InputStreamReader(socket.getInputStream()));                 //进行普通的io操作                String line=br.readLine();                System. out.println( "来自服务器的数据：：" +line);                br.close();                ps.close();                 socket.close();           }

效果如下：      注意：服务器和客户端互相发送的数据都是已经编译好的。但是通常情况下，我们发送数据，都是想发什么就发什么，所以呢，应该通过键盘输入来发送数据。      但是通过键盘输入，需要监听用户键盘输入。这个键盘输入会有一定的问题。      比如客户端发送数据如下：还是在上述demo的Client端基础上： [html] view plain copy print ?

1.  //获取该socket对应的输出流  

2. PrintStream ps= new PrintStream(s.getOutputStream());  

3. String line= null;  

4. //不断读取键盘的输入  

5. BufferedReader br= new BufferedReader( new InputStreamReader(System.in));  

6. while((line=br.readLine())!= null)  

7. {  

8.     //将用户的键盘输入内容写入socket对应的输出流  

9.     ps.println(line);  

10. }  

                //获取该socket对应的输出流              PrintStream ps= new PrintStream(s.getOutputStream());              String line= null;              //不断读取键盘的输入              BufferedReader br= new BufferedReader( new InputStreamReader(System.in));              while((line=br.readLine())!= null)              {                   //将用户的键盘输入内容写入socket对应的输出流                   ps.println(line);              }

     请注意看system.in这个方法，则程序一直在死循环中，则无法执行下面的接受服务器方法。      也许你说，那直接在循环中，发送完毕后，直接接受。      但是这种办法，就会造成，你在dos窗口中只能发一条语句，然后，等待接受。      那该怎么办呢？我想发送数据和我的接受数据不相关分离，并不是硬生生滴绑定在一块。

转载于:https://blog.51cto.com/longx/1351581