devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java 基于TCP协议的Socket编程和通信_bufferedwriter out = new bufferedwriter(new output

作者：木道寻08 | 2024-07-19 09:40:40

赞

踩

bufferedwriter out = new bufferedwriter(new outputstreamwriter(socket.getout

  在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序，简称客户端，而在第一次通讯中等待连接的程序被称作服务器端(Server)程序，简称服务器。一旦通讯建立，则客户端和服务器端完全一样，没有本质的区别。

请求-响应”模式：

      1. Socket类：发送TCP消息。

      2. ServerSocket类：创建服务器。

      套接字是一种进程间的数据交换机制。这些进程既可以在同一机器上，也可以在通过网络连接的不同机器上。换句话说，套接字起到通信端点的作用。单个套接字是一个端点，而一对套接字则构成一个双向通信信道，使非关联进程可以在本地或通过网络进行数据交换。一旦建立套接字连接，数据即可在相同或不同的系统中双向或单向发送，直到其中一个端点关闭连接。套接字与主机地址和端口地址相关联。主机地址就是客户端或服务器程序所在的主机的IP地址。端口地址是指客户端或服务器程序使用的主机的通信端口。

      在客户端和服务器中，分别创建独立的Socket，并通过Socket的属性，将两个Socket进行连接，这样，客户端和服务器通过套接字所建立的连接使用输入输出流进行通信。

      TCP/IP套接字是最可靠的双向流协议，使用TCP/IP可以发送任意数量的数据。

      实际上，套接字只是计算机上已编号的端口。如果发送方和接收方计算机确定好端口，他们就可以通信了。

TCP/IP通信连接的简单过程：

      位于A计算机上的TCP/IP软件向B计算机发送包含端口号的消息，B计算机的TCP/IP软件接收该消息，并进行检查，查看是否有它知道的程序正在该端口上接收消息。如果有，他就将该消息交给这个程序。

      要使程序有效地运行，就必须有一个客户端和一个服务器。

通过Socket的编程顺序：

      1. 创建服务器ServerSocket，在创建时，定义ServerSocket的监听端口(在这个端口接收客户端发来的消息)。

      2. ServerSocket调用accept()方法，使之处于阻塞状态。

      3. 创建客户端Socket，并设置服务器的IP及端口。

      4. 客户端发出连接请求，建立连接。

      5. 分别取得服务器和客户端Socket的InputStream和OutputStream。

      6. 利用Socket和ServerSocket进行数据传输。

      7. 关闭流及Socket。

单向通信

服务器端

  1. import java.io.BufferedWriter;
  2. import java.io.IOException;
  3. import java.io.OutputStreamWriter;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6.  
  7. /**
  8.  * 最简单的服务器端代码
  9.  * @author Administrator
  10.  */
  11. public class BasicSocketServer {
  12.     public static void main(String[] args) {
  13.         Socket socket = null;
  14.         BufferedWriter bw = null;
  15.         try {
  16.             // 建立服务器端套接字：指定监听的接口
  17.             ServerSocket serverSocket = new ServerSocket(8888);
  18.             System.out.println("服务端建立监听");
  19.             // 监听，等待客户端请求，并愿意接收连接
  20.             socket = serverSocket.accept();
  21.             // 获取socket的输出流，并使用缓冲流进行包装
  22.             bw = new BufferedWriter(new     
  23.                                     OutputStreamWriter(socket.getOutputStream()));
  24.             // 向客户端发送反馈信息
  25.             bw.write("hhhh");
  26.         } catch (IOException e) {
  27.             e.printStackTrace();
  28.         } finally {
  29.             // 关闭流及socket连接
  30.             if (bw != null) {
  31.                 try {
  32.                     bw.close();
  33.                 } catch (IOException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.             }
  37.             if (socket != null) {
  38.                 try {
  39.                     socket.close();
  40.                 } catch (IOException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.         }
  45.     }
  46. }

客户端

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.net.InetAddress;
  5. import java.net.Socket;
  6. /**
  7.  * 最简单的Socket客户端
  8.  * @author Administrator
  9.  */
  10. public class BasicSocketClient {
  11.     public static void main(String[] args) {
  12.         Socket socket = null;
  13.         BufferedReader br = null;
  14.         try {
  15.             /*
  16.              * 创建Scoket对象：指定要连接的服务器的IP和端口而不是自己机器的
  17.              * 端口。发送端口是随机的。
  18.              */
  19.             socket = new Socket(InetAddress.getLocalHost(), 8888);
  20.             //获取scoket的输入流，并使用缓冲流进行包装
  21.             br = new BufferedReader(new  
  22.                                    InputStreamReader(socket.getInputStream()));
  23.             //接收服务器端发送的信息
  24.             System.out.println(br.readLine());
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.         } finally {
  28.             // 关闭流及socket连接
  29.             if (br != null) {
  30.                 try {
  31.                     br.close();
  32.                 } catch (IOException e) {
  33.                     e.printStackTrace();
  34.                 }
  35.             }
  36.             if (socket != null) {
  37.                 try {
  38.                     socket.close();
  39.                 } catch (IOException e) {
  40.                     e.printStackTrace();
  41.                 }
  42.             }
  43.         }
  44.     }
  45. }

双向通信

服务器端

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStreamWriter;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8.  
  9. public class Server {
  10.     public static void main(String[] args){
  11.         Socket socket = null;
  12.         BufferedReader in = null;
  13.         BufferedWriter out = null;
  14.         BufferedReader br = null;
  15.         try {
  16.             //创建服务器端套接字：指定监听端口
  17.             ServerSocket server = new ServerSocket(8888);
  18.             //监听客户端的连接
  19.             socket = server.accept();
  20.             //获取socket的输入输出流接收和发送信息
  21.             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  22.             out = new BufferedWriter(new 
  23.                                    OutputStreamWriter(socket.getOutputStream()));
  24.             br = new BufferedReader(new InputStreamReader(System.in));
  25.             while (true) {
  26.                 //接收客户端发送的信息
  27.                 String str = in.readLine();
  28.                 System.out.println("客户端说：" + str);
  29.                 String str2 = "";
  30.                 //如果客户端发送的是“end”则终止连接 
  31.                 if (str.equals("end")){
  32.                     break;
  33.                 }
  34.                 //否则，发送反馈信息
  35.                 str2 = br.readLine(); // 读到\n为止，因此一定要输入换行符！
  36.                 out.write(str2 + "\n");
  37.                 out.flush();
  38.             }
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             //关闭资源
  43.             if(in != null){
  44.                 try {
  45.                     in.close();
  46.                 } catch (IOException e) {
  47.                     e.printStackTrace();
  48.                 }
  49.             }
  50.             if(out != null){
  51.                 try {
  52.                     out.close();
  53.                 } catch (IOException e) {
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.             if(br != null){
  58.                 try {
  59.                     br.close();
  60.                 } catch (IOException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.             if(socket != null){
  65.                 try {
  66.                     socket.close();
  67.                 } catch (IOException e) {
  68.                     e.printStackTrace();
  69.                 }
  70.             }
  71.         }
  72.     }
  73. }

客户端

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStreamWriter;
  6. import java.net.InetAddress;
  7. import java.net.Socket;
  8. import java.net.UnknownHostException;
  9.  
  10. public class Client {
  11.     public static void main(String[] args) {
  12.         Socket socket = null;
  13.         BufferedReader in = null;
  14.         BufferedWriter out = null;
  15.         BufferedReader wt = null;
  16.         try {
  17.             //创建Socket对象，指定服务器端的IP与端口
  18.             socket = new Socket(InetAddress.getLocalHost(), 8888);
  19.             //获取scoket的输入输出流接收和发送信息
  20.             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  21.             out = new BufferedWriter(new 
  22.                                    OutputStreamWriter(socket.getOutputStream()));
  23.             wt = new BufferedReader(new InputStreamReader(System.in));
  24.             while (true) {
  25.                 //发送信息
  26.                 String str = wt.readLine();
  27.                 out.write(str + "\n");
  28.                 out.flush();
  29.                 //如果输入的信息为“end”则终止连接
  30.                 if (str.equals("end")) {
  31.                     break;
  32.                 }
  33.                 //否则，接收并输出服务器端信息
  34.                 System.out.println("服务器端说：" + in.readLine());
  35.             }
  36.         } catch (UnknownHostException e) {
  37.             e.printStackTrace();
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         } finally {
  41.             // 关闭资源
  42.             if (out != null) {
  43.                 try {
  44.                     out.close();
  45.                 } catch (IOException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.             if (in != null) {
  50.                 try {
  51.                     in.close();
  52.                 } catch (IOException e) {
  53.                     e.printStackTrace();
  54.                 }
  55.             }
  56.             if (wt != null) {
  57.                 try {
  58.                     wt.close();
  59.                 } catch (IOException e) {
  60.                     e.printStackTrace();
  61.                 }
  62.             }
  63.             if (socket != null) {
  64.                 try {
  65.                     socket.close();
  66.                 } catch (IOException e) {
  67.                     e.printStackTrace();
  68.                 }
  69.             }
  70.         }
  71.     }
  72. }

聊天室

服务器端

  1. package cn.menglangpoem.chat;
  2.  
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8. import java.util.List;
  9. import java.util.concurrent.CopyOnWriteArrayList;
  10.  
  11. /**
  12.  * 聊天室服务器
  13.  */
  14. public class Server {
  15.     //准备容器，存储客户端
  16.     private static List<Chanel> list = new CopyOnWriteArrayList<>();
  17.  
  18.  
  19.  
  20.     //主函数
  21.     public static void main(String[] args) throws IOException {
  22.         int num = 0;
  23.         //创建服务器
  24.         ServerSocket server = null;
  25.         try {
  26.              server = new ServerSocket(8888);
  27.             System.out.println("服务器已启动，端口号---->8888");
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         }
  31.         while(true)
  32.         {
  33.             //接收客户端
  34.             Socket client = server.accept();
  35.             num++;
  36.             System.out.println(num+"个服务器已连接");
  37.             //存储到容器
  38.             Chanel chanel = new Chanel(client);
  39.             list.add(chanel);
  40.             //开启线程
  41.             new Thread(chanel).start();
  42.         }
  43.     }
  44.  
  45.  
  46.  
  47.     //信号通道
  48.     static class Chanel implements Runnable{
  49.         private Socket clinet = null;//客户端
  50.         private boolean flag = true;//控制运行
  51.         private DataInputStream clientR = null; //读信息
  52.         private DataOutputStream clientW = null;//写信息
  53.         private String name; //客户端姓名
  54.         public Chanel(Socket clinet) {
  55.             this.clinet = clinet;
  56.             //初始化
  57.             try {
  58.                 this.clientR = new DataInputStream(clinet.getInputStream());
  59.                 this.clientW = new DataOutputStream(clinet.getOutputStream());
  60.                 this.name = clientR.readUTF();
  61.                 this.send("欢迎来到聊天室！");
  62.             } catch (IOException e) {
  63.                 //e.printStackTrace();
  64.                 System.out.println("初始化失败！");
  65.                 flag = false;
  66.             }
  67.         }
  68.  
  69.         @Override
  70.         public void run() {
  71.             while(flag)
  72.             {
  73.                 sendOthers();
  74.             }
  75.         }
  76.         //发送
  77.         private void send(String msg)
  78.         {
  79.  
  80.             //判断是否为空
  81.                 try {
  82.                     //System.out.println("send ---- "+msg);
  83.                     clientW.writeUTF(msg);
  84.                     clientW.flush();
  85.                 } catch (IOException e) {
  86.                     //e.printStackTrace();
  87.                     System.out.println("发送失败！");
  88.                     flag = false;
  89.                 }
  90.         }
  91.  
  92.         //接收
  93.         private String receive()
  94.         {
  95.             String msg = null;
  96.             try {
  97.                 msg = clientR.readUTF();
  98.             } catch (IOException e) {
  99.                 //e.printStackTrace();
  100.                 System.out.println("接收失败！");
  101.                 flag = false;
  102.             }
  103.             return msg;
  104.         }
  105.  
  106.         //发送群消息
  107.         private void sendOthers()
  108.         {
  109.             String msg = receive();
  110.             for(Chanel other: list)
  111.             {
  112.                 if(other == this)
  113.                     continue;
  114.                 else
  115.                 {
  116.                     other.send(this.name+"说"+msg);
  117.                 }
  118.             }
  119.         }
  120.     }
  121. }

客户端

  1. package cn.menglangpoem.chat;
  2.  
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.Socket;
  7. import java.util.Scanner;
  8.  
  9. /**
  10.  * 聊天客户端
  11.  */
  12. public class Client {
  13.     public static void main(String[] args) throws IOException {
  14.         //连接服务器
  15.         Socket server = new Socket("localhost",8888);
  16.         //启动线程
  17.         new Thread(new Send(server)).start();
  18.         new Thread(new Receive(server)).start();
  19.         System.out.println("请输入昵称");
  20.     }
  21.  
  22.  
  23.     //接收信息
  24.     static class Receive implements Runnable{
  25.         private Socket server = null;
  26.         private boolean flag = true;
  27.         DataInputStream serverR = null;
  28.         //构造函数
  29.         public Receive(Socket server) {
  30.             //初始化
  31.             this.server = server;
  32.             try {
  33.                 this.serverR = new DataInputStream(server.getInputStream());
  34.             } catch (IOException e) {
  35.                 e.printStackTrace();
  36.                 flag = false;
  37.             }
  38.         }
  39.  
  40.         @Override
  41.         public void run() {
  42.             while (flag)
  43.             {
  44.                 System.out.println(receive());
  45.             }
  46.         }
  47.         private String receive()
  48.         {
  49.             String msg = null;
  50.             try {
  51.                 msg = serverR.readUTF();
  52.             } catch (IOException e) {
  53.                 //e.printStackTrace();
  54.                 System.out.println("接收信息失败！");
  55.                 flag = false;
  56.             }
  57.             return msg;
  58.         }
  59.     }
  60.  
  61.  
  62.     //发送信息
  63.     static class Send implements Runnable{
  64.         private Socket server = null;
  65.         private DataOutputStream serverW = null;
  66.         private boolean flag = true;
  67.  
  68.         public Send(Socket server) {
  69.             this.server = server;
  70.             try {
  71.                 serverW = new DataOutputStream(server.getOutputStream());
  72.             } catch (IOException e) {
  73.                 e.printStackTrace();
  74.             }
  75.         }
  76.         //线程体
  77.         @Override
  78.         public void run() {
  79.             while (flag)
  80.                 send();
  81.         }
  82.         //发送函数
  83.         private void send()
  84.         {
  85.             Scanner scanner = new Scanner(System.in);
  86.             String msg = scanner.next();
  87.             try {
  88.                 serverW.writeUTF(msg);
  89.                 serverW.flush();
  90.             } catch (IOException e) {
  91.                 e.printStackTrace();
  92.                 System.out.println("发送信息失败！");
  93.                 flag = false;
  94.             }
  95.  
  96.         }
  97.     }
  98. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/850727
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号