javax.net网络编程完全指南：核心类解析与实战代码示例

import javax.net.SocketFactory;
import java.io.*;
import java.net.Socket;

public class BasicSocketClient {
    public static void main(String[] args) {
        try {
            // 使用默认的 SocketFactory 创建 Socket
            SocketFactory factory = SocketFactory.getDefault();
            Socket socket = factory.createSocket("localhost", 8080);
            
            // 获取输出流发送数据
            OutputStream output = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(output, true);
            writer.println("Hello Server!");
            
            // 获取输入流接收响应
            InputStream input = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(input));
            String response = reader.readLine();
            System.out.println("Server response: " + response);
            
            // 关闭连接
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import javax.net.ServerSocketFactory;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class BasicSocketServer {
    public static void main(String[] args) {
        try {
            // 使用默认的 ServerSocketFactory 创建 ServerSocket
            ServerSocketFactory factory = ServerSocketFactory.getDefault();
            ServerSocket serverSocket = factory.createServerSocket(8080);
            
            System.out.println("Server started on port 8080");
            
            while (true) {
                // 等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress());
                
                // 处理客户端请求
                handleClient(clientSocket);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private static void handleClient(Socket clientSocket) {
        try {
            // 获取输入流读取客户端数据
            InputStream input = clientSocket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(input));
            String message = reader.readLine();
            System.out.println("Received from client: " + message);
            
            // 发送响应
            OutputStream output = clientSocket.getOutputStream();
            PrintWriter writer = new PrintWriter(output, true);
            writer.println("Hello Client! I received your message: " + message);
            
            // 关闭连接
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import javax.net.SocketFactory;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;

// 自定义 SocketFactory
public class CustomSocketFactory extends SocketFactory {
    private final SocketFactory defaultFactory = SocketFactory.getDefault();
    
    @Override
    public Socket createSocket(String host, int port) throws IOException {
        System.out.println("Creating socket to " + host + ":" + port);
        Socket socket = defaultFactory.createSocket(host, port);
        // 可以在这里添加自定义配置
        socket.setSoTimeout(5000); // 设置超时时间
        return socket;
    }
    
    @Override
    public Socket createSocket(String host, int port, InetAddress localAddr, int localPort) 
            throws IOException {
        System.out.println("Creating socket to " + host + ":" + port + 
                          " from local address " + localAddr + ":" + localPort);
        return defaultFactory.createSocket(host, port, localAddr, localPort);
    }
    
    @Override
    public Socket createSocket(InetAddress address, int port) throws IOException {
        System.out.println("Creating socket to " + address + ":" + port);
        return defaultFactory.createSocket(address, port);
    }
    
    @Override
    public Socket createSocket(InetAddress address, int port, InetAddress localAddr, int localPort) 
            throws IOException {
        return defaultFactory.createSocket(address, port, localAddr, localPort);
    }
}

// 使用自定义 SocketFactory 的客户端
public class CustomSocketClient {
    public static void main(String[] args) {
        try {
            SocketFactory customFactory = new CustomSocketFactory();
            Socket socket = customFactory.createSocket("localhost", 8080);
            
            // 使用 socket 进行通信...
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import javax.net.ServerSocketFactory;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadedServer {
    private static final int THREAD_POOL_SIZE = 10;
    private static final ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
    
    public static void main(String[] args) {
        try {
            ServerSocketFactory factory = ServerSocketFactory.getDefault();
            ServerSocket serverSocket = factory.createServerSocket(8080);
            
            System.out.println("Multi-threaded server started on port 8080");
            
            while (true) {
                Socket clientSocket = serverSocket.accept();
                // 为每个客户端连接创建新线程处理
                executor.execute(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
    
    static class ClientHandler implements Runnable {
        private final Socket clientSocket;
        
        public ClientHandler(Socket socket) {
            this.clientSocket = socket;
        }
        
        @Override
        public void run() {
            try {
                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true);
                
                String message;
                while ((message = reader.readLine()) != null) {
                    System.out.println("Received: " + message);
                    writer.println("Echo: " + message);
                    
                    if ("bye".equalsIgnoreCase(message)) {
                        break;
                    }
                }
                
                clientSocket.close();
                System.out.println("Client disconnected: " + clientSocket.getInetAddress());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}