计算机网络 --- 网络编程

转x33g5p2x  于2022-05-05 转载在 其他  
字(17.8k)|赞(0)|评价(0)|浏览(1062)

1. 网络编程

1.1 什么是网络编程

网络编程 : 指网络上的主机,通过不同的进程,以编程的方式实现网络通信.
简单来说: 网络编程就是通过代码的方式来控制不同进程间能够进行数据交互.

1.2 发送端和接收端

发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端

1.3 请求和响应

请求(Request) : 客户端给服务端发送的数据
响应(Response) : 服务端给客户端返回的数据

1.4 客户端和服务端

客户端 : 主动发送请求的一方
服务端 : 被动接受请求的一方

客户端和服务端的交互方式:

  1. 一问一答,客户端发送一个请求,服务端给一个响应
  2. 一问多答,客户端发送一个请求,服务端给多个响应
  3. 多问一答,客户端发送多个请求,服务端给一个响应
  4. 多问多答,客户端发送多个请求,服务器端多个响应

2. Socket 套接字

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程.

2.1 分类

流套接字 : 使用传输层 TCP 协议

TCP协议,(Transmission Control Protocol)
TCP的特点:

  1. 有连接
  2. 可靠传输
  3. 面向字节流
  4. 有接收缓冲区,也有发送缓冲区
  5. 大小不限
  6. 全双工

数据报接字 : 使用传输层 UDP 协议

UDP协议,(User Datagram Protocl)
UDP的特点:

  1. 无连接
  2. 不可靠传输
  3. 面向数据报
  4. 有接收缓冲区,无发送缓冲区
  5. 大小受限: 一次最多传输64k
  6. 全双工

3. UDP数据报套接字编程

3.1 DatagramSocket API

DatagramSocket 是UDP Socket, 用于发送和接收UDP数据报.

构造方法

方法签名方法说明
DatagramSocket()创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）
DatagramSocket(int port)创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）

方法

方法签名方法说明
void receive(DatagramPacket p)从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p)从此套接字发送数据报包（不会阻塞等待，直接发送）
void close()关闭此数据报套接字

3.2 DatagramPacket API

DatagramPacket是UDP Socket发送和接收的数据报.

构造方法

方法签名方法说明
DatagramPacket(byte[] buf, int length)构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数length）
DatagramPacket(byte[] buf, int offset, int length,SocketAddress address)构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号

方法

方法签名方法说明
InetAddress getAddress()从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort()从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()获取数据报中的数据

注: 构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。
InetSocketAddress的构造方法

方法签名方法说明
InetSocketAddress(InetAddress addr, int port)创建一个Socket地址，包含IP地址和端口号

3.3 基本使用方法:

服务端:

  1. 创建一个 DatagramSocket 对象,创建的同时关联一个端口号
  2. 读取请求 并解析
  3. 根据请求计算响应
  4. 把响应写回到客户端
  5. 打印日志

客户端

  1. 创建一个 DatagramSocket 对象,创建的同时指定服务器的ip和端口号
  2. 读取输入的数据
  3. 构造请求 并 发送给服务器
  4. 从服务器读取响应
  5. 把数据显示给用户

使用示例: 一发一收

代码示例: UdpServer

  1. import java.io.IOException;
  2. import java.net.DatagramPacket;
  3. import java.net.DatagramSocket;
  4. import java.net.SocketException;
  6. public class UdpEchoServer {
  7.     private DatagramSocket socket = null;
  9.     public UdpEchoServer(int port) throws SocketException {
  10.         this.socket = new DatagramSocket(port);
  11.     }
  13.     public void start() throws IOException {
  14.         System.out.println("服务器启动!");
  15.         while (true) {
  16.             // 1. 读取请求 并 解析
  17.             DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
  18.             socket.receive(requestPacket);
  19.             String request = new String(requestPacket.getData(),0, requestPacket.getLength());
  20.             // 2. 根据请求计算响应
  21.             String response = process(request);
  22.             // 3. 把响应写回到客户端
  23.             DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
  24.                                                                 requestPacket.getSocketAddress());
  25.             socket.send(responsePacket);
  26.             // 4. 打印日志
  27.             String log = String.format("[%s:%d] req: %s; resp: %s",requestPacket.getAddress().toString(),
  28.                                                                 requestPacket.getPort(),request,response);
  29.             System.out.println(log);
  30.         }
  31.     }
  33.     private String process(String request) {
  34.         return request;
  35.     }
  37.     public static void main(String[] args) throws IOException {
  38.         UdpEchoServer server = new UdpEchoServer(9090);
  39.         server.start();
  40.     }
  41. }

代码示例: UdpClient

  1. import java.io.IOException;
  2. import java.net.*;
  3. import java.util.Scanner;
  5. public class UdpEchoClient {
  6.     private DatagramSocket socket = null;
  7.     private String serverIp;
  8.     private int serverPort;
  10.     public UdpEchoClient(String serverIp,int serverPort) throws SocketException {
  11.         this.serverIp = serverIp;
  12.         this.serverPort = serverPort;
  13.         this.socket = new DatagramSocket();
  14.     }
  16.     public void start() throws IOException {
  17.         while (true) {
  18.             // 1. 读取输入数据
  19.             System.out.print("->");
  20.             Scanner sc = new Scanner(System.in);
  21.             String request = sc.next();
  22.             if(request.equals("exit")){
  23.                 System.out.println("exit");
  24.                 break;
  25.             }
  27.             // 2. 构造请求 并 发送给服务器
  28.             DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length,
  29.                                                         InetAddress.getByName(serverIp),serverPort);
  30.             socket.send(requestPacket);
  32.             // 3. 读取服务器的响应 并 解析
  33.             DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
  34.             socket.receive(responsePacket);
  35.             String response = new String(responsePacket.getData(),0, responsePacket.getLength());
  37.             // 4.显式给用户
  38.             String log = String.format("req: %s; resp: %s",request,response);
  39.             System.out.println(log);
  40.         }
  41.     }
  43.     public static void main(String[] args) throws IOException {
  44.         UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
  45.         client.start();
  46.     }
  47. }

运行结果:

使用示例: 翻译程序

客户端 输入需要查找的英文的请求
客户端 返回对应的英文翻译的响应
代码示例: UdpServer

  1. package Translation;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.SocketException;
  7. import java.util.HashMap;
  8. import java.util.Map;
  10. public class UdpTranslateServer {
  11.     private DatagramSocket socket = null;
  12.     private Map<String,String> map = new HashMap<>();
  14.     public UdpTranslateServer(int port) throws SocketException {
  15.         this.socket = new DatagramSocket(port);
  16.         map.put("translate","翻译");
  17.         map.put("china","中国");
  18.         map.put("hello","你好");
  19.     }
  21.     public void start() throws IOException {
  22.         System.out.println("服务器启动!");
  23.         while (true) {
  24.             // 1. 读取请求并解析
  25.             DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
  26.             socket.receive(requestPacket);
  27.             String request = new String(requestPacket.getData(),0, requestPacket.getLength());
  28.             // 2. 根据请求计算响应
  29.             String response = process(request);
  30.             // 3. 把响应写回给客户端
  31.             DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
  32.                                                                 requestPacket.getSocketAddress());
  33.             socket.send(responsePacket);
  34.             // 4. 打印日志
  35.             String log = String.format("[%s:%d] req: %s; resp: %s",requestPacket.getAddress().toString(),
  36.                                         requestPacket.getPort(),request,response);
  37.             System.out.println(log);
  38.         }
  39.     }
  41.     private String process(String request) {
  42.         return map.getOrDefault(request,"查无此单词");
  43.     }
  45.     public static void main(String[] args) throws IOException {
  46.         UdpTranslateServer server = new UdpTranslateServer(9090);
  47.         server.start();
  48.     }
  49. }

代码示例: UDPClient

  1. package Translation;
  3. import java.io.IOException;
  4. import java.net.*;
  5. import java.util.Scanner;
  7. public class UdpTranslateClient {
  8.     private DatagramSocket socket = null;
  9.     private String serverIp;
  10.     private int serverPort;
  12.     public UdpTranslateClient (String serverIp,int serverPort) throws SocketException {
  13.         this.serverIp = serverIp;
  14.         this.serverPort = serverPort;
  15.         socket = new DatagramSocket();
  16.     }
  18.     public void start() throws IOException {
  19.         while (true) {
  20.             System.out.print("->");
  21.             Scanner sc = new Scanner(System.in);
  22.             // 1. 根据用户的输入 构造请求
  23.             String request = sc.next();
  24.             if(request.equals("exit")){
  25.                 System.out.println("exit!");
  26.                 return;
  27.             }
  28.             // 2. 发送请求给服务器
  29.             DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
  30.                                                     InetAddress.getByName(serverIp),serverPort);
  31.             socket.send(requestPacket);
  32.             // 3. 读取服务器的响应
  33.             DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
  34.             socket.receive(responsePacket);
  35.             String response = new String(responsePacket.getData(),0, responsePacket.getLength());
  36.             System.out.println(response);
  37.             // 4. 解析响应并显式
  38.             String log = String.format("req: %s; resp: %s",request,response);
  39.             System.out.println(log);
  40.         }
  41.     }
  43.     public static void main(String[] args) throws IOException {
  44.         UdpTranslateClient client = new UdpTranslateClient("127.0.0.1",9090);
  45.         client.start();
  46.     }
  47. }

运行结果:

4. TCP流套接字编程

4.1 ServerSocket API

构造方法

方法签名方法说明
ServerSocket(int port)创建一个服务端流套接字Socket，并绑定到指定端口

方法

方法签名方法说明
Socket accept()开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接，否则阻塞等待
void close()关闭此套接字

4.2 Socket API

构造方法

方法签名方法说明
Socket(String host, int port)创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接

方法

方法签名方法说明
InetAddress getInetAddress()返回套接字所连接的地址
InputStream getInputStream()返回此套接字的输入流
OutputStream getOutputStream()返回此套接字的输出流

4.3 基本使用方法

服务器

  1. 创建ServerSocket 关联上一个端口号

  • 调用 ServerSocket 的 accept 方法

  • 目的是 建立连接

  • 会返回一个 Socket 实例,称为 clientSocket

  • 使用 clientSocket 的 getInputStream 和 getOutputStream 得到字节流对象,进行读写和写入

  • 读取请求 并 解析

  • 根据请求计算响应

  • 把响应写回客户端

  • 打印日志

  • 当客户端断开连接之后,服务器就应该要及时的关闭 clientSocket. (防止出现文件泄露的情况)

客户端

  1. 创建一个 Socket 对象.创建的同时指定服务器的 ip 和端口

  • 客户端就可以通过 Socket 对象的 getInputStream 和 getOutputStream 来和服务器进行通信

  • 从键盘上,读取用户输入的内容

  • 把这个读取的内容构造成请求,发送给服务端

  • 从服务器读取响应并解析

  • 把结构显示到界面上

使用示例1: 一发一收

这里的是普通版本 不能处理多个客户端

代码示例: TCPClient

  1. package TCP;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.util.Scanner;
  10. public class TcpEchoClient {
  11.     private Socket socket = null;
  12.     private String serverIp;
  13.     private int serverPort;
  15.     public TcpEchoClient(String serverIp,int serverPort) throws IOException {
  16.         this.serverIp = serverIp;
  17.         this.serverPort = serverPort;
  18.         // 让 socket 创建的同时,就和服务器尝试建立连接
  19.         this.socket = new Socket(serverIp,serverPort);
  20.     }
  22.     public void start() {
  23.         Scanner scanner = new Scanner(System.in);
  24.         try(InputStream inputStream = socket.getInputStream();
  25.             OutputStream outputStream = socket.getOutputStream()){
  26.             while (true) {
  27.                 // 1. 从键盘上,读取用户输入的内容
  28.                 System.out.print("->");
  29.                 String request = scanner.next();
  30.                 if (request.equals("exit")){
  31.                     break;
  32.                 }
  33.                 // 2. 把这个读取的内容构造成请求,发送给服务器
  34.                 PrintWriter printWriter = new PrintWriter(outputStream);
  35.                 printWriter.println(request);
  36.                 printWriter.flush();
  37.                 // 3. 从服务器读取响应并解析
  38.                 Scanner respScanner = new Scanner(inputStream);
  39.                 String response = respScanner.next();
  40.                 // 4. 把结果显示到界面上
  41.                 String log = String.format("req: %s; resp: %s",request,response);
  42.                 System.out.println(log);
  43.             }
  44.         } catch (IOException e) {
  45.             e.printStackTrace();
  46.         }
  47.     }
  49.     public static void main(String[] args) throws IOException {
  50.         TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);
  51.         client.start();
  52.     }
  53. }

代码示例: TCPServer

  1. package TCP;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.Scanner;
  11. public class TcpEchoServer {
  12.     private ServerSocket listenSocket = null;
  14.     public TcpEchoServer(int port) throws IOException {
  15.         listenSocket = new ServerSocket(port);
  16.     }
  18.     public void start() throws IOException {
  19.         System.out.println("服务器启动!");
  20.         while (true) {
  21.             // 1. 建立连接
  22.             Socket clientSocket = listenSocket.accept(); // 没有客户端来就会 阻塞等待
  23.             processConnection(clientSocket);
  24.         }
  25.     }
  27.     private void processConnection(Socket clientSocket) throws IOException {
  28.         String log = String.format("[%s:%d] 客户端上线!",
  29.                 clientSocket.getInetAddress().toString(),clientSocket.getPort());
  30.         System.out.println(log);
  31.         try(InputStream inputStream = clientSocket.getInputStream();
  32.             OutputStream outputStream = clientSocket.getOutputStream()) {
  33.             while (true) {
  34.                 // 1. 读取请求并解析
  35.                 Scanner scanner = new Scanner(inputStream);
  36.                 if(!scanner.hasNext()){
  37.                     log = String.format("[%s:%d] 客户端下线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
  38.                     System.out.println(log);
  39.                     break;
  40.                 }
  41.                 String request = scanner.next();
  42.                 // 2. 根据请求计算响应
  43.                 String response = process(request);
  44.                 // 3. 把响应写回给客户端
  45.                 PrintWriter writer = new PrintWriter(outputStream);
  46.                 writer.println(response);
  47.                 writer.flush();
  49.                 log = String.format("[%s:%d] req: %s; resp: %s",clientSocket.getInetAddress().toString(),
  50.                         clientSocket.getPort(),request,response);
  51.                 System.out.println(log);
  52.             }
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.         } finally {
  56.             clientSocket.close();
  57.         }
  58.     }
  60.     private String process(String request) {
  61.         return request;
  62.     }
  64.     public static void main(String[] args) throws IOException {
  65.         TcpEchoServer server =  new TcpEchoServer(9090);
  66.         server.start();
  67.     }
  68. }

使用示例2: 多个客户端发 一个服务器收

多线程版本,能处理多个客户端,但是需要频繁的创建销毁线程
代码示例 TCPServer (客户端一致)

  1. package TCPThread;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.Scanner;
  11. public class TcpThreadEchoServer {
  12.     private ServerSocket listenSocket = null;
  14.     public TcpThreadEchoServer(int port) throws IOException {
  15.         listenSocket = new ServerSocket(port);
  16.     }
  18.     public void start() throws IOException {
  19.         System.out.println("服务器启动!");
  20.         while (true) {
  21.             Socket clientSocket = listenSocket.accept();
  22.             // 创建一个线程来给这个客户提供服务
  23.             Thread t = new Thread(){
  24.                 @Override
  25.                 public void run() {
  26.                     try {
  27.                         processConnection(clientSocket);
  28.                     } catch (IOException e) {
  29.                         e.printStackTrace();
  30.                     }
  31.                 }
  32.             };
  33.             t.start();
  34.         }
  35.     }
  36.     public void processConnection(Socket clientSocket) throws IOException {
  37.         // 1. 打印日志
  38.         String log = String.format("[%s,%d] 客户端上线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
  39.         System.out.println(log);
  40.         try (InputStream inputStream = clientSocket.getInputStream();
  41.              OutputStream outputStream = clientSocket.getOutputStream()){
  42.             while (true) {
  43.                 // 1. 读取 请求 并 解析
  44.                 Scanner sc = new Scanner(inputStream);
  45.                 if(!sc.hasNext()){
  46.                     log = String.format("[%s,%d] 客户端下线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
  47.                     System.out.println(log);
  48.                     break;
  49.                 }
  50.                 String request = sc.next();
  51.                 // 2. 根据请求计算响应
  52.                 String response = process(request);
  53.                 // 3. 把响应写回客户端
  54.                 PrintWriter printWriter = new PrintWriter(outputStream);
  55.                 printWriter.println(response);
  56.                 printWriter.flush();
  57.                 // 4. 打印日志
  58.                 log = String.format("[%s:%d] req: %s; resp: %s",clientSocket.getInetAddress().toString(),
  59.                         clientSocket.getPort(),request,response);
  60.                 System.out.println(log);
  61.             }
  62.         } catch (IOException e) {
  63.             e.printStackTrace();
  64.         } finally {
  65.             clientSocket.close();
  66.         }
  67.     }
  69.     public String process(String request){
  70.         return request;
  71.     }
  73.     public static void main(String[] args) throws IOException {
  74.         TcpThreadEchoServer server = new TcpThreadEchoServer(9090);
  75.         server.start();
  76.     }
  77. }

使用示例3: 多个客户端发 一个服务器收(优化版)

由于多线程版的创建销毁线程的开销太大,这里使用线程池的方法.

  1. package TCPThread;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.Scanner;
  10. import java.util.concurrent.ExecutorService;
  11. import java.util.concurrent.Executors;
  13. public class TcpThreadPoolEchoServer {
  14.     private ServerSocket listenSocket = null;
  16.     public TcpThreadPoolEchoServer(int port) throws IOException {
  17.         listenSocket = new ServerSocket(port);
  18.     }
  20.     public void start() throws IOException {
  21.         System.out.println("服务器启动");
  22.         ExecutorService executorService = Executors.newCachedThreadPool();
  23.         while (true) {
  24.             Socket clientSocket = listenSocket.accept();
  25.             // 使用线程池 来 处理当前的 processConnextion
  26.             executorService.submit(()-> {
  27.                 try {
  28.                     processConnection(clientSocket);
  29.                 } catch (IOException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.             });
  33.         }
  34.     }
  35.     public void processConnection(Socket clientSocket) throws IOException {
  36.         // 1. 打印日志
  37.         String log = String.format("[%s,%d] 客户端上线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
  38.         System.out.println(log);
  39.         try (InputStream inputStream = clientSocket.getInputStream();
  40.              OutputStream outputStream = clientSocket.getOutputStream()){
  41.             while (true) {
  42.                 // 1. 读取 请求 并 解析
  43.                 Scanner sc = new Scanner(inputStream);
  44.                 if(!sc.hasNext()){
  45.                     log = String.format("[%s,%d] 客户端下线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
  46.                     System.out.println(log);
  47.                     break;
  48.                 }
  49.                 String request = sc.next();
  50.                 // 2. 根据请求计算响应
  51.                 String response = process(request);
  52.                 // 3. 把响应写回客户端
  53.                 PrintWriter printWriter = new PrintWriter(outputStream);
  54.                 printWriter.println(response);
  55.                 printWriter.flush();
  56.                 // 4. 打印日志
  57.                 log = String.format("[%s:%d] req: %s; resp: %s",clientSocket.getInetAddress().toString(),
  58.                         clientSocket.getPort(),request,response);
  59.                 System.out.println(log);
  60.             }
  61.         } catch (IOException e) {
  62.             e.printStackTrace();
  63.         } finally {
  64.             clientSocket.close();
  65.         }
  66.     }
  68.     public String process(String request){
  69.         return request;
  70.     }
  72. }

运行结果

使用示例4: 翻译程序

代码示例: TCPServer (这里的客户端还是跟前面一样)

  1. package Translation;
  3. import TCPThread.TcpThreadPoolEchoServer;
  5. import java.io.IOException;
  6. import java.util.HashMap;
  8. // echo 和 translate 两个服务器之间,大多都是类似的
  9. public class TcpTranslateServer extends TcpThreadPoolEchoServer {
  10.     private HashMap<String,String> map = new HashMap<>();
  12.     public TcpTranslateServer(int port) throws IOException {
  13.         super(port);
  14.         map.put("china","中国");
  15.         map.put("hello","你好");
  16.         map.put("translate","翻译");
  17.     }
  19.     @Override
  20.     public String process(String request) {
  21.         return map.getOrDefault(request,"查无此单词!");
  22.     }
  24.     public static void main(String[] args) throws IOException {
  25.         TcpTranslateServer server = new TcpTranslateServer(9090);
  26.         server.start();
  27.     }
  28. }

运行结果:

5. 网络计算器(自定义协议)

我们自定义协议
请求 : 字符串类型 操作数1;操作数2;运算符
响应 : 字符串类型 计算响应

服务端代码

  1. package Calculator;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.InetAddress;
  7. import java.net.SocketException;
  9. public class CalcServer {
  10.     private DatagramSocket socket = null;
  12.     public CalcServer(int port) throws SocketException {
  13.         socket = new DatagramSocket(port);
  14.     }
  16.     public void start() throws IOException {
  17.         System.out.println("服务器启动!");
  18.         while (true){
  19.             // 1. 读取请求并解析
  20.             DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
  21.             socket.receive(requestPacket);
  22.             String request = new String(requestPacket.getData(),0,requestPacket.getLength());
  23.             // 2. 跟据请求计算响应
  24.             String response = process(request);
  25.             // 3. 把响应写回给客户端
  26.             DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
  27.                                                             requestPacket.getSocketAddress());
  28.             socket.send(responsePacket);
  29.             // 4. 打印日志
  30.             String log = String.format("[%s:%d] req: %s; resp: %s",requestPacket.getAddress().toString(),
  31.                                     requestPacket.getPort(),request,response);
  32.             System.out.println(log);
  33.         }
  34.     }
  36.     private String process(String request) {
  37.         // 分离
  38.         String[] str = request.split(";");
  39.         if(str.length != 3) return "[请求的格式出错!]";
  40.         int num1 = Integer.parseInt(str[0]);
  41.         int num2 = Integer.parseInt(str[1]);
  42.         if(str[2].equals("+")){
  43.             return num1+num2+"";
  44.         }else if(str[2].equals("-")){
  45.             return num1-num2+"";
  46.         }else if(str[2].equals("*")){
  47.             return (num1 * num2)+"";
  48.         }else if(str[2].equals("/")){
  49.             return (num1 / num2)+"";
  50.         }
  51.         return "[请求格式出错!操作符不支持!]";
  52.     }
  54.     public static void main(String[] args) throws IOException {
  55.         CalcServer server = new CalcServer(9090);
  56.         server.start();
  57.     }
  58. }

客户端代码

  1. package Calculator;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.InetAddress;
  7. import java.net.SocketException;
  8. import java.util.Scanner;
  10. public class CalcClient {
  11.     private String serverIp;
  12.     private int serverPort;
  13.     private DatagramSocket socket = null;
  15.     public CalcClient(String serverIp,int serverPort) throws SocketException {
  16.         this.serverIp = serverIp;
  17.         this.serverPort = serverPort;
  18.         socket = new DatagramSocket();
  19.     }
  21.     public void start() throws IOException {
  22.         Scanner sc = new Scanner(System.in);
  23.         while (true) {
  24.             // 1. 用户输入的请求
  25.             System.out.print("请输入操作数1: ");
  26.             int num1 = sc.nextInt();
  27.             System.out.print("请输入操作数2: ");
  28.             int num2 = sc.nextInt();
  29.             System.out.print("请输入运算符: ");
  30.             String operator = sc.next();
  31.             String request = num1+";"+num2+";"+operator;
  32.             // 2. 构造请求,并发给服务器
  33.             DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length,
  34.                     InetAddress.getByName(serverIp),serverPort);
  35.             socket.send(requestPacket);
  36.             // 3. 从服务器中读取响应
  37.             DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
  38.             socket.receive(responsePacket);
  39.             String response = new String(responsePacket.getData(),0,responsePacket.getLength());
  41.             // 4. 将结果显示到屏幕上
  42.             String log = String.format("req: %s; resp: %s",request,response);
  43.             System.out.println(log);
  44.         }
  45.     }
  47.     public static void main(String[] args) throws IOException {
  48.         CalcClient client = new CalcClient("127.0.0.1",9090);
  49.         client.start();
  50.     }
  51. }

运行结果:

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://wangzhi430.blog.csdn.net/article/details/123847671

内容来源于网络，如有侵权，请联系作者删除！

tcp/ip计算机网络网络协议网络安全

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com