网络通信之server/client通信的实现

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了网络通信之server/client通信的实现相关的知识,希望对你有一定的参考价值。

要求:实现服务器客户端通信,当服务器启动后一旦有客户端连接上服务器,服务器便给连接上的客户端发送”欢迎光临!“。每增加一个客户端,服务器都将客户端放入arraylist中,并显示在线客户端数。而客户端向服务器发送消息时,服务器会接收客户端发来的消息并将消息转发给所以在线的客户端。客户端和服务器端都有自己的发送和接收数据的线程。 
服务端要求实现的功能: 
      1.每连上一个客户端,就主动给客户端发送一句“欢迎光临!”。 
      2.使用ArrayList存放连上服务端的所有客户端。 
      3.当接收到客户端发送来的消息的时候,将这条消息转发给所有连上服务端的所有客户端。 

思路: 
      1.创建一个服务器套接字(ServerSocket),绑定到指定端口。 
     2.调用accept方法,侦听来自客户端的请求,如果客户发出请求,则接受连接,返回通信套接字(Socket)。 
      3.创建线程来处理客户机:发送和接收消息。
 

服务端: 下载

Java代码  技术分享

  1. //服务器端  

  2. public class MyServer {  

  3.     //使用ArrayList存放连上服务端的所有客户端  

  4.     public static ArrayList<Socket> sockets = new ArrayList<Socket>();  

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

  6.             try {  

  7.                 //创建一个服务器套接字,绑定到54321端口  

  8.                 ServerSocket server = new ServerSocket(54321);  

  9.                 System.out.println("服务器已启动,正在等待连接");  

  10.                 while (true) {  

  11.                     //调用accept方法,侦听来自客户端的请求  

  12.                     Socket socket = server.accept();  

  13.                     //将客户端发送过来的通信套接字添加到sockets动态数组中  

  14.                     sockets.add(socket);  

  15.                     //输出在线的客户端个数  

  16.                     System.out.println("有" + sockets.size() + "个客户连接上");  

  17.                     //启动发送线程,给客户端发送一句“欢迎光临!”  

  18.                     new getOutputStream(socket).start();  

  19.                     //启动接收线程,读取从客户端发来的消息  

  20.                     new getInputStream(socket).start();  

  21.                 }  

  22.             } catch (IOException e) {  

  23.                 e.printStackTrace();  

  24.             }  

  25.         }  

  26.     }  



服务端负责发送欢迎光临的线程类: 

Java代码  技术分享

  1. //发送线程负责给客户端发送一句“欢迎光临!”  

  2.     class getOutputStream extends Thread{  

  3.         private Socket s;  

  4.         public getOutputStream(Socket s) {  

  5.             this.s=s;  

  6.         }  

  7.         @Override  

  8.         public void run() {  

  9.             try {  

  10.                 //获取输出流  

  11.                 OutputStream ops= s.getOutputStream();  

  12.                 String msg="欢迎光临!\n";  

  13.                 //将msg写入流  

  14.                 ops.write(msg.getBytes());  

  15.                 //刷新流  

  16.                 ops.flush();  

  17.                   

  18.             } catch (IOException e) {  

  19.                 e.printStackTrace();  

  20.             }  

  21.         }  

  22.     }  



服务器端从客户端接收数据的线程类: 

Java代码  技术分享

  1. //接收线程,读取从客户端发来的消息  

  2.     class getInputStream extends Thread {  

  3.         private Socket r;  

  4.         public getInputStream(Socket r) {  

  5.             this.r = r;  

  6.         }  

  7.         public void run() {  

  8.             try {  

  9.                 //获取输入流  

  10.                 InputStreamReader is = new InputStreamReader(r.getInputStream());  

  11.                 BufferedReader br = new BufferedReader(is);  

  12.                 while (true) {  

  13.                     //读取客户端发送过来的消息  

  14.                     String msg = br.readLine();  

  15.                     System.out.println("客户端发来" + msg);  

  16.                     //读取客户端发送过来的消息后转发给所有在线的客户端  

  17.                     for (Socket socket : MyServer.sockets) {  

  18.                         OutputStreamWriter osw = new OutputStreamWriter(  

  19.                                 socket.getOutputStream());  

  20.                         BufferedWriter bw = new BufferedWriter(osw);  

  21.                         bw.write(msg + "\n");  

  22.                         //刷新流  

  23.                         bw.flush();  

  24.                           

  25.                     }  

  26.                 }  

  27.             } catch (Exception e) {  

  28.                 e.printStackTrace();  

  29.             }  

  30.         }  

  31.     }  




客户端 
功能: 
      1.在命令行给服务端发送消息 
      2.当接收到服务端发来的消息的时候,将内容显示在控制台上 
思路: 
      1.创建一个套接字(Socket) ,向服务器的侦听端口发出请求 
      2.与服务器正确连接后,获得输入/输出流,启动线程开始网络数据的接收和发送
 

客户端: 

Java代码  技术分享

  1. //客户端  

  2. public class MyClient {  

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

  4.             try {  

  5.                 //创建一个套接字(Socket) ,向服务器的侦听端口发出请求  

  6.                 Socket socket = new Socket("localhost"54321);  

  7.                 //启动读取数据线程,接收服务器发送过来的消息  

  8.                 new Cread(socket).start();  

  9.                 //启动发送数据线程,给服务器发送消息  

  10.                 new Csend(socket).start();  

  11.             } catch (UnknownHostException e) {  

  12.                 e.printStackTrace();  

  13.             } catch (IOException e) {  

  14.                 e.printStackTrace();  

  15.             }  

  16.         }  

  17.     }  



客户端接收数据的线程类: 

Java代码  技术分享

  1. //读取数据线程,接收服务器发送过来的消息  

  2.     class Cread extends Thread {  

  3.         private Socket r;  

  4.         public Cread(Socket r) {  

  5.             this.r = r;  

  6.         }  

  7.         public void run() {  

  8.             try {  

  9.                 while (true) {  

  10.                     //获取输入流  

  11.                     InputStreamReader is = new InputStreamReader(r.getInputStream());  

  12.                     BufferedReader br = new BufferedReader(is);  

  13.                     //按行读取从服务器发来的数据消息  

  14.                     String content = br.readLine();  

  15.                     System.out.println("服务端发来" + content);  

  16.                 }  

  17.             } catch (UnknownHostException e) {  

  18.                 e.printStackTrace();  

  19.             } catch (IOException e) {  

  20.                 e.printStackTrace();  

  21.             }  

  22.         }  

  23.     }  



客户端发送数据线程类: 

Java代码  技术分享

  1. //发送数据线程,给服务器发送消息  

  2.     class Csend extends Thread {  

  3.         private Socket c;  

  4.         public Csend(Socket c) {  

  5.             this.c = c;  

  6.         }  

  7.         public void run() {  

  8.             try {  

  9.                 //获取输出流  

  10.                 OutputStreamWriter osw = new OutputStreamWriter(c.getOutputStream());  

  11.                 BufferedWriter bw = new BufferedWriter(osw);  

  12.                 //从键盘写入数据  

  13.                 Scanner sc = new Scanner(System.in);  

  14.                 while (true) {  

  15.                     //将键盘写入的数据按行写入发送给服务器  

  16.                     String msg = sc.nextLine() + "\n";  

  17.                     bw.write(msg);  

  18.                     System.out.println("给服务器发送" + msg);  

  19.                     //刷新流  

  20.                     bw.flush();  

  21.                 }  

  22.                   

  23.             } catch (IOException e) {  

  24.                 e.printStackTrace();  

  25.             }  

  26.         }  

  27.     }  


以上是关于网络通信之server/client通信的实现的主要内容,如果未能解决你的问题,请参考以下文章

通过Redis的list来实现 Server - Client 的同步通信

基于I/O的Server/Client实现

简单的通信----使用Socket实现TCP协议

胡说八道计算机网络之什么是网络?

Java回顾之网络通信

java之网络通信框架mina