【网络原理】网络编程Socket套接字基础知识汇总

//UDP版本:回显服务器的服务器部分
public class UdpEchoServer {
    private DatagramSocket socket = null;
    //参数的端口表示服务器要绑定的端口
    //不需要指定IP，就是本机的IP
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    //启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动了！！！");
        while(true){
            //1.读取请求并且解析
            //socket的receive操作需要一个空的requestPacket，receive方法的参数是一个输出型参数
            //将空的DatagramPacket对象交给receive，在receive里面负责把从网卡读到的数据填充到这个对象中
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024],1024);//要给DatagramPacket申请内存空间
            socket.receive(requestPacket);
            //将DatagramPacket转换成字符串    getData()是获取数据报中的数据，返回一个byte[]
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());
            //2.根据请求计算响应
            String response = process(request);
            //3.把响应返回给客户端
            //发送DatagramPacket对象需要指定IP地址和端口号
            DatagramPacket responsePacket = new DatagramPacket(    //getSocketAddress就是得到客户端的IP和端口号
                    response.getBytes(),response.getBytes().length, requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //4.打印一个日志
            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 {
        UdpEchoServer server = new UdpEchoServer(1025);
        server.start();
    }
}

//UDP版本:回显服务器的客户端部分
public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;
    //服务器的IP一般不用写，就是本机的IP
    //需要传服务器的IP和服务器的端口
    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.nextLine();
            //2.构造一个UDP请求，发送给服务器
            DatagramPacket requestPacket = new DatagramPacket(
                    //request.getBytes().length这里的length单位是字节
                    //request.length()这里的length()单位是字符，不可以改成这样
                    request.getBytes(),request.getBytes().length, InetAddress.getByName(this.serverIP),this.serverPort);
            socket.send(requestPacket);
            //3.从服务器接收响应，并且转成字符串
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0, responsePacket.getLength());
            //4.把响应显示到控制台上
            System.out.println(response);
        }
    }
    public static void main(String[] args) throws IOException {
        //IP是某某食堂，端口号是某某窗口
        UdpEchoClient client = new UdpEchoClient("127.0.0.1",1025);
        client.start();
    }
}

//TCP版本：回显服务器服务器部分
public class TcpEchoServer {
    private ServerSocket listenSocket = null;
    public TcpEchoServer(int port) throws IOException {
        listenSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动！！");
        //使用线程池
        ExecutorService service = Executors.newCachedThreadPool();
        while(true) {
            //1.先调用accept
            Socket clientSocket = listenSocket.accept();
            //2.再来处理这个连接,这里应该使用多线程，每个客户端连上来都分配一个新的线程负责处理
            //使用多线程确实可以解决问题，但是会频繁的创建和销毁线程！
//            Thread t = new Thread(()->{
//                try {
//                    processConnection(clientSocket);
//                } catch (IOException e) {
//                    throw new RuntimeException(e);
//                }
//            });
//            t.start();
            service.submit(new Runnable() {
                @Override
                public void run() {
                    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());
        //处理客户端的请求
        //clientSocket代表的是服务器的网卡，inputStream代表从网卡读数据也就相当于从客户端读取数据
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()){
            while(true){
                //1.读取请求并且解析
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()){
                    System.out.printf("[%s:%d] 客户端下线！\n",
                            clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                String request = scanner.next();
                //2.根据请求计算响应
                String response = process(request);
                //3.把响应写回到客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                //刷新缓冲区确保数据确实是通过网卡发送出去了
                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要关闭文件，前面的listenSocket和UDP程序中的socket都不需要关闭文件呢？
            clientSocket.close();
        }
    }
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090);
        server.start();
    }
}

//TCP版本：回显服务器客户端部分
public class TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        socket = new Socket(serverIp, serverPort);
    }
    public void start() {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            while (true) {
                //1.从控制台读取数据
                System.out.print("-> ");
                String request = scanner.next();
                //2.发送请求给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();
                //3.从服务器上接收响应
                Scanner respScanner = new Scanner(inputStream);
                String response = respScanner.next();
                //4.把响应显示到界面上
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException {
        TcpEchoClient server = new TcpEchoClient("127.0.0.1",9090);
        server.start();
    }
}