基于 Socket 网络编程

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

// Echo-回显服务器。客户端发了个请求，服务器返回一个一模一样的响应。
public class UdpEchoSever {
    // 需要先定义一个 socket 对象，使用网络通信，必须要使用 socekt 对象
    private DatagramSocket socket = null;
    // 绑定一个端口号，不一定能成功，比如某个端口号已经被别的进程占用了，此时这里的绑定操作就会出错。
    // 需要注意的是：同一个主机上，一个端口，同一时刻，只能被一个进程绑定。
    public UdpEchoSever(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    // 启动服务器主逻辑
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // 每次循环，做三件事
            // 1. 读取请求并解析
            //    构造一个空的DatagramPacket对象，用来接收客户端请求
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            //    从网卡上接收请求 此处的 requestPacket 为输出型参数
            socket.receive(requestPacket);
            //    这里为了方便处理这个请求，将数据包转化为 String
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            // 2. 根据请求计算响应
            String response = process(request);
            // 3. 把响应结果写回到客户端
            //    根据 response 字符串，构造一个 DatagramPacket
            //    和请求 packet 不同，此处构造响应的时候，需要指定这个包要发给谁
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                    // requestPacket 是从客户端这里收来的，getSocketAddress 会得到客户端的 ip 何为端口
                    requestPacket.getSocketAddress());
                    
            socket.send(responsePacket);
            // 方面查看，打印一下日志
            // ip 和 端口号 + 请求内容 + 响应内容
            System.out.printf("[%s:%d] req: %s, resp: %s\n",requestPacket.getAddress().toString(),requestPacket.getPort(),request,response);
        }
    }

    // process是请求处理方法，这是服务器中的一个关键环节！！！
    public String process(String request) {
        return request;
    }
    
  // 主函数
    public static void main(String[] args) throws IOException {
        UdpEchoSever udpEchoSever = new UdpEchoSever(9090);
        udpEchoSever.start();
    }
}

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;

    // 客户端启动, 需要知道服务器在哪里!!
    public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
        // 对于客户端来说, 不需要显示关联端口.
        // 不代表没有端口, 而是系统自动分配了个空闲的端口.
        socket = new DatagramSocket();
        this.serverIP = serverIP;
        this.serverPort = serverPort;
    }

    public void start() throws IOException {
        // 通过这个客户端可以多次和服务器进行交互.
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 先从控制台, 读取一个字符串过来
            //    先打印一个提示符, 提示用户要输入内容
            System.out.print("-> ");
            String request = scanner.next();
            // 2. 把字符串构造成 UDP packet, 并进行发送.
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIP), serverPort);
            socket.send(requestPacket);
            // 3. 客户端尝试读取服务器返回的响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            // 4. 把响应数据转换成 String 显示出来.
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            System.out.printf("req: %s, resp: %s\n", request, response);
        }
    }

    public static void main(String[] args) throws IOException {
      // 127.0.0.1 是一个特殊的IP地址，表示本机的回环地址。
        UdpEchoClient udpEchoClient = new UdpEchoClient("127.0.0.1", 9090);
        udpEchoClient.start();
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TcpEchoSever {
    // 这里有个比喻：
    // severSocket 看做是外场拉客的小哥
    // clientSocket 看做内场服务的小姐姐
    // severSocket 只有一个，clientSocket 会给每个客户端都分配一个

    private ServerSocket serverSocket = null;

    public TcpEchoSever(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        ExecutorService pool = Executors.newCachedThreadPool();
        while (true) {
            Socket clientSocket = serverSocket.accept();
            // 如果直接调用，该方法会影响这个循环的二次执行，导致 accept 不及时
            // 创建新线程，用新线程调用 processConnection
            // 每次来一个新的客户端都创建一个新线程

            // 1.方案一：每次创建线程（每次创建销毁，开销较大）
//            Thread t = new Thread(()->{
//                processConnection(clientSocket);
//            });
//            t.start();

            // 2.方案二：使用线程池
            pool.submit(()->{
                try {
                    processConnection((clientSocket));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        // 打印一下日志
        System.out.printf("[%s:%d] 客户端上线!\n",clientSocket.getInetAddress().toString(),
                clientSocket.getPort());
        // try () 这种写法，( ) 中允许写多个流对象，使用 ; 分割
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 为了简单，把字节流包装成了更方便的字符流
            Scanner scanner = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);

            // 一次可能发来多个请求，这里规定以 \n 为分隔符
            while (true) {
                // 1.读取请求
                // 特殊处理一下：
                if (!scanner.hasNext()) {
                    // 读取的流到了结尾（对端关闭了）
                    System.out.printf("[%s:%d] 客户端下线!\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                // 直接使用 scanner 读取一段字符串
                String request = scanner.next();
                // 2.根据请求计算响应
                String response = process(request);
                // 3.把响应写会给客户端，不要忘了，响应里也是要带上换行的
                printWriter.println(response);
                // 写网卡为全缓冲，这里使用flush刷新
                printWriter.flush();
                // 最后打印一下日志
                System.out.printf("[%s:%d] req: %s resp: %s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
          // 关闭连接
            clientSocket.close();
        }
    }
    
    // 处理请求
    public String process(String request) {
        return request;
    }
  // 主方法
    public static void main(String[] args) throws IOException {
        TcpEchoSever tcpEchoSever = new TcpEchoSever(9090);
        tcpEchoSever.start();
    }

}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

// idea 中默认一个程序只能启动一个，启动多个客户端可配置一下 IDEA。

public class TcpEchoClient {
    private Socket socket = null;

    // ***只有这里会建立连接，和 Udp 不同***
    public TcpEchoClient(String severIp, int port) throws IOException {
        // 这个操作就相当于让客户端和服务器建立 TCP 连接
        // 这里的链接连上了，accept 就会返回
        socket = new Socket(severIp,port);
    }

    public void start() {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            // 将字节流包装成字符流
            Scanner scannerFromSocket = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1.从键盘上读取用户输入的内容
                System.out.print("->");
                String request = scanner.next();
                // 2.把读取的内容构成请求，发给服务器
                //   注意：这里的发送，是带换行的！
                printWriter.println(request);
                // 写网卡为全缓冲，这里使用flush刷新
                printWriter.flush();
                // 3.从服务器读取响应内容
                String response = scannerFromSocket.next();
                // 4. 把响应的结果显示到控制台上
                System.out.printf("req: %s ; resq: %s\n",request,response);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
  // 主方法
    public static void main(String[] args) throws IOException {
        TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1",9090);
        tcpEchoClient.start();
    }

}