网络编程套接字(Socket)

public class Udp_server {
    private DatagramSocket socket = null;
    public Udp_server(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    // 服务器的启动逻辑.
    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            // 每次循环, 就是处理一个请求-响应过程.
            // 1. 读取请求并解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);
            // 读到的字节数组, 转成 String 方便后续的逻辑处理.
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
            // 2. 根据请求计算响应 (对于 回显服务器来说, 这一步啥都不用做)
            String response = process(request);
            // 3. 把响应返回到客户端.
            //    构造一个 DatagramPacket 作为响应对象
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);
            // 打印日志
            System.out.printf("[%s:%d] req: %s, resp: %s\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }
    }
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        Udp_server server = new Udp_server(9090);
        server.start();
    }
}

public class UDP_Client {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;
    // 此处 ip 使用的字符串, 点分十进制风格. "192.168.2.100"
    public UDP_Client(String serverIp, int serverPort) throws SocketException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        socket = new DatagramSocket();
    }
    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 要做四个事情
            System.out.print("-> "); // 表示提示用户接下来要输入内容.
            // 2. 从控制台读取要发送的请求数据.
            if (!scanner.hasNext()) {
                break;
            }
            String request = scanner.next();
            // 3. 构造请求并发送.
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            // 4. 读取服务器的响应.
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            // 5. 把响应显示到控制台上.
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            System.out.println(response);
        }
    }
    public static void main(String[] args) throws IOException {
        UDP_Client client = new UDP_Client("127.0.0.1", 9090);
        client.start();
    }
}

public class TCPEchoClient {
    private Socket socket= null;
    public TCPEchoClient(String serverIP, int port) throws IOException {
        socket = new Socket(serverIP,port);
        //由于TCP是有连接的,所以IP和端口会保存好
        //因此TCPEchoClient就不必保存
    }
    public void start() {
        System.out.println("客户端启动");
        //和UDP类似
        //1.从控制台读取
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerConsole = new Scanner(System.in);
            Scanner scannerNetwork = new Scanner(inputStream);
            PrintWriter writer = new PrintWriter(outputStream);
            while(true) {
                System.out.print("->");
                if(!scannerConsole.hasNext()) {
                    break;
                }
                String request = scannerConsole.next();
                writer.println(request);
                //2.请求发给服务器
                //确保这里发送出去了
                writer.flush();
                //3.读取响应
                String response = scannerNetwork.next();
                //4.把响应显示出来
                System.out.println(response);
            }
        } catch (IOException e) {
        }
    }
    public static void main(String[] args) throws IOException {
        TCPEchoClient client = new TCPEchoClient("127.0.0.1",9090);
        client.start();
    }
}

public class TCPEchoServer {
    private ServerSocket serverSocket = null;
    public TCPEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public  void  start() throws IOException {
        System.out.println("服务器启动");
        ExecutorService pool = Executors.newCachedThreadPool();
        while(true) {
            //通过accept来接听电话,才能通信(置业顾问)
            Socket clientSocket = serverSocket.accept();
//            Thread t = new Thread(()->{
//                processConnection(clientSocket);
//            });
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
        }
    }
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d]客户端上线\n",clientSocket.getInetAddress(),clientSocket.getPort());
        //循环读取客户端的请求并返client
        try(InputStream inputStream = clientSocket.getInputStream();
                OutputStream OutputStream = clientSocket.getOutputStream()){
            //使用Scanner就不使用read了
            Scanner scanner = new Scanner(inputStream);
            while(true) {
                //使用inputStream
                if(!scanner.hasNext()) {
                    //读取完毕,比如客户端断开连接就算读取完毕
                    System.out.printf("[%s:%d] 客户端下线\n",clientSocket.getInetAddress(),clientSocket.getPort());
                    break;
                }
                //读取请求并解析,这里注意隐藏的约定,客户端发来的请求必须带有空白符作为结尾
                String request = scanner.next();
                //计算请求
                String response = process(request);
                //返回给客户端
                //这种方式可以写会但不方便给返回的响应添加换行
//                OutputStream.write(response.getBytes(StandardCharsets.UTF_8),0,response.getBytes().length);
                //也可以给OutputStream套上一层
                //将输出流包装一下,这里的操作也就是将字节流转换为字符流
                PrintWriter printWriter = new PrintWriter(OutputStream);
                printWriter.println(response);
                printWriter.flush();
                System.out.printf("[%s:%d] req %s,resp : %s\n",clientSocket.getInetAddress(),clientSocket.getPort(),
                        request,response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally{
            try {
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TCPEchoServer server = new TCPEchoServer(9090);
        server.start();
    }
}