*/***
* * 服务器不需要知道数据从哪里来，所以不需要用字段来存放客户端的IP和端口，直接从请求中获取即可*
* */*
public class Server {
*    *private DatagramSocket socket = null; *// 通信就靠DatagramSocket对象*
 
*    *public Server(int port) throws SocketException {
        socket = new DatagramSocket(port); *// 服务端需要指定port，让别人来连接*
*    *}
 
    public void start() throws IOException {
        System.*out*.println("服务器启动！");
        while(true) {
            *// 1. （阻塞）接收客户端发来的请求，并且进行解析*
*            *DatagramPacket req = new DatagramPacket(new byte[4096], 4096);
            socket.receive(req);
            String data = new String(req.getData(), 0, req.getLength()); *// 从 DatagramPacket 取到有效的数据*
 
*            // 2. 处理请求*
*            *String outcome = func(data);
 
            *// 3. 封装成数据报进行响应（注意要填写目的端口和ip）*
*            *DatagramPacket resp = new DatagramPacket(outcome.getBytes(),
                    0,
                    outcome.getBytes().length,
                    *//req.getAddress(), req.getPort()); // 可以这样子写，但是麻烦，推荐下面的写法*
*                    *req.getSocketAddress());
            socket.send(resp);
 
            *// 打印日志，看看效果*
*            *System.*out*.printf("[%s:%d] req: %s, resp: %s\n", req.getAddress(), req.getPort(), data, outcome);
        }
    }
    
    *// 业务代码（不是现在的重点）*
*    *public String func(String data) {
        return data;
    }
 
    public static void main(String[] args) throws IOException {
        Server server = new Server(8080);
        server.start();
    }
}

*/***
* * 1. 因为客户端在发送数据报的时候需要知道服务器的IP和端口，并且由于UDP*
* *    每次发送数据都得传入服务器的IP和端口，所以需要用单独的字段来保存*
* **
* * 2. 创建DatagramSocket时候传入的端口是指定客户端自己在本机的端口，*
* *    而不是服务器的端口，注意和上面区分开！*
* */*
public class Client {
    private int port;    *// 服务器的端口*
*    *private String addr; *// 服务器的地址*
*    *private DatagramSocket socket = null;
 
    public Client(int port, String addr) throws SocketException {
        this.port = port;
        this.addr = addr;
        socket = new DatagramSocket(); *// 让系统自动分配端口号*
*    *}
 
    public void start() throws IOException {
        System.*out*.println("客户端启动！");
        Scanner sc = new Scanner(System.*in*);
 
        while(true) {
            *// 1. 构造请求数据报，注意要传入目的端口和IP到数据报中*
*            *System.*out*.print("请输入要发送给服务器的信息：");
            String message = sc.nextLine();
            DatagramPacket req = new DatagramPacket(message.getBytes(),
                    0,
                    message.getBytes().length,
                    InetAddress.*getByName*(addr), // 利用静态方法getByName构造InetAddress
                    port);
 
            *// 2. 发送请求到服务器*
*            *socket.send(req);
 
            *// 3. 接收服务器发来的响应，然后进行解析*
*            *DatagramPacket resp = new DatagramPacket(new byte[4096], 4096);
            socket.receive(resp);
            String data = new String(resp.getData(), 0, resp.getLength());
 
            *// 进行日志输出，查看效果*
*            *System.*out*.println("响应：" + data);
        }
    }
 
    public static void main(String[] args) throws IOException {
        Client client = new Client(8080, "127.0.0.1");
        client.start();
    }
}

*/***
* *  服务器只需要指定端口即可*
* */*
public class Server {
    private ServerSocket socket = null;
 
    public Server(int port) throws IOException {
        socket = new ServerSocket(port);
    }
 
    public void start() throws IOException {
        System.*out*.println("TCP服务器启动！");
        while(true) {
            *// 1. 监听新连接*
*            *Socket conn = socket.accept();
            System.*out*.println("获取到新连接：" + conn.getInetAddress() + "/" + conn.getPort());
 
            *// 2. 创建新线程来处理新连接，防止主线程阻塞*
*            *new Thread(() -> {
                work(conn);
            }).start();
        }
    }
 
    *// 新连接实际上要处理的任务*
*    *private void work(Socket conn) {
        try (InputStream in = conn.getInputStream();
             OutputStream out = conn.getOutputStream();
             Scanner sc = new Scanner(in);
             PrintWriter pw = new PrintWriter(out)) {
            while(true) {
                *// 3. 读取请求并进行解析*
*                *if(sc.hasNextLine() == false) {
                    *// 要判断是否断开连接：如果客户端断开连接了，则会返回false*
*                    *System.*out*.printf("[%s:%d] 客户端下线！\n", conn.getInetAddress().toString(), conn.getPort());
                    break;
                }
                String req = sc.nextLine();
 
                *// 4. 将解析后的请求进行业务处理*
*                *String resp = func(req);
 
                *// 5. 响应结果给客户端*
*                *pw.println(resp); *// ✔自动添加换行符，满足服务端 Scanner.nextLine()，使用write则会死循环！*
*                *pw.flush();       *// ❗❗❗细节❗❗❗*
 
*                // 搞一下日志输出看看效果*
*                *System.*out*.printf("[%s:%d] req: %s, resp: %s\n", conn.getInetAddress().toString(), conn.getPort()
                                                               , req, resp);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            *// 6. 释放Socket资源*
*            *try {
                conn.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
 
    private String func(String data) {
        return data;
    }
 
    public static void main(String[] args) throws IOException {
        Server server = new Server(9090);
        server.start();
    }
}

public void start() throws IOException {
        System.*out*.println("TCP服务器启动！");
        while(true) {
            *// 监听新连接*
*            *Socket conn = socket.accept();
            System.*out*.println("获取到新连接：" + conn.getInetAddress() + "/" + conn.getPort());
            
*            // 创建线程池来处理新连接，推荐用newCachedThreadPool*
*            *ExecutorService pool = Executors.*newCachedThreadPool*();
            pool.submit(() -> {
                work(conn);
            });
        }
    }

public class Client {
    private Socket conn = null;
 
    public Client(String addr, int port) throws IOException {
        conn = new Socket(addr, port);
    }
 
    public void start() {
        System.*out*.println("客户端启动！");
        Scanner tmp = new Scanner(System.*in*);
        try (InputStream in = conn.getInputStream();
             OutputStream out = conn.getOutputStream();
             Scanner sc = new Scanner(in);
             PrintWriter pw = new PrintWriter(out)) {
            while(true) {
                *// 1. 输入数据，写入Socket中，然后刷新*
*                *System.*out*.print("请输入要发送的数据：");
                String req = tmp.nextLine();
                pw.println(req);  *// ✔自动添加换行符，满足服务端 Scanner.nextLine()，使用write则会死循环！*
*                *pw.flush();       *// ❗❗❗细节❗❗❗*
 
*                // 2. 接收服务器的响应*
*                *if(sc.hasNextLine() == false) {
                    System.*out*.println("客户端断开连续！");
                    break;
                }
                String resp = sc.nextLine();
 
                *// 打印日志看看效果*
*                *System.*out*.printf("[%s:%d] req: %s, resp: %s\n", conn.getInetAddress().toString(),
                                                                 conn.getPort(),
                                                                 req, resp);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
 
    public static void main(String[] args) throws IOException {
        Client client = new Client("127.0.0.1", 9090);
        client.start();
    }
}