Java SocketAPI关键代码详细使用介绍(Java Socket API核心代码实战详解)

原创

ithorizon 6个月前 (10-19) 阅读数 21 #后端开发

Java Socket API关键代码详细使用介绍

一、Java Socket API 简介

Java Socket API 是 Java 网络编程的基础，它提供了一套充裕的网络通信接口，令 Java 程序可以方便地实现客户端和服务器之间的数据传输。Socket API 核心是基于 TCP/IP 协议和 UDP 协议进行网络通信的。

二、Socket API 核心类

Java Socket API 的核心类核心包括以下几个：

Socket：用于实现客户端的 TCP 连接。

ServerSocket：用于实现服务器的 TCP 连接。

DatagramSocket：用于实现 UDP 数据包通信。

InetAddress：用于获取 IP 地址和域名。

三、Socket API 实战详解

3.1 TCP 客户端实现

下面是一个明了的 TCP 客户端实现，它连接到服务器，并发送一条消息。


public class TCPClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 12345);
            OutputStream os = socket.getOutputStream();
            PrintStream ps = new PrintStream(os);
            ps.println("Hello, Server!");
            ps.close();
            os.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.2 TCP 服务器实现

下面是一个明了的 TCP 服务器实现，它监听指定端口，接收客户端发送的消息，并打印。


public class TCPServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(12345);
            Socket socket = serverSocket.accept();
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String message = br.readLine();
            System.out.println("Received message: " + message);
            br.close();
            is.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3 UDP 客户端实现

下面是一个明了的 UDP 客户端实现，它发送一个数据包到服务器。


public class UDPClient {
    public static void main(String[] args) {
        try {
            DatagramSocket socket = new DatagramSocket();
            InetAddress address = InetAddress.getByName("localhost");
            byte[] buffer = "Hello, Server!".getBytes();
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, 12345);
            socket.send(packet);
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.4 UDP 服务器实现

下面是一个明了的 UDP 服务器实现，它接收客户端发送的数据包，并打印。


public class UDPServer {
    public static void main(String[] args) {
        try {
            DatagramSocket socket = new DatagramSocket(12345);
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            socket.receive(packet);
            String message = new String(packet.getData(), 0, packet.getLength());
            System.out.println("Received message: " + message);
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

四、Socket API 高级特性

除了基本的 Socket 通信外，Java Socket API 还提供了许多高级特性，如多线程、非阻塞 I/O、SSL 加密等。以下是一些高级特性的明了示例。

4.1 多线程 Socket 服务器

下面是一个使用线程池实现的多线程 Socket 服务器示例。


import java.io.*;
import java.net.*;
import java.util.concurrent.*;
public class MultiThreadedServer {
    private static final int PORT = 12345;
    private static final int MAX_THREADS = 10;
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(MAX_THREADS);
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            while (true) {
                Socket clientSocket = serverSocket.accept();
                executor.submit(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
    private static class ClientHandler implements Runnable {
        private Socket clientSocket;
        public ClientHandler(Socket socket) {
            this.clientSocket = socket;
        }
        @Override
        public void run() {
            try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                 PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    out.println("Echo: " + inputLine);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.2 非阻塞 I/O

Java Socket API 也赞成非阻塞 I/O，这通常是通过使用 Selector 类来实现的。


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class NonBlockingServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(12345));
        serverSocket.configureBlocking(false);
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            selector.select();
            Set selectedKeys = selector.selectedKeys();
            Iterator iter = selectedKeys.iterator();
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove();
                if (key.isAcceptable()) {
                    register(selector, serverSocket);
                }
                if (key.isReadable()) {
                    handleRead(key);
                }
            }
        }
    }
    private static void register(Selector selector, ServerSocketChannel serverSocket) throws IOException {
        SocketChannel client = serverSocket.accept();
        client.configureBlocking(false);
        client.register(selector, SelectionKey.OP_READ);
    }
    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel client = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int read = client.read(buffer);
        if (read == -1) {
            client.close();
            return;
        }
        buffer.flip();
        String received = new String(buffer.array(), 0, read);
        System.out.println("Received: " + received);
        buffer.clear();
    }
}