Java服务端和客户端

在Java中，"服务端"和"客户端"是网络通信中的两个基本概念。服务端（Server）通常指在网络中提供各种服务的计算机程序或设备，例如提供网页的HTTP服务器或提供数据库访问的数据库服务器。客户端（Client）则是发起请求以获取服务端提供的服务的程序或设备。

在Java网络编程中，使用java.net包下的类和接口进行服务端和客户端的实现。下面是服务端和客户端编程的一些基本概念和步骤：

服务端 (Server)

服务端程序通常需要执行以下步骤：

1. 打开服务器端口：使用ServerSocket类在特定端口上创建一个服务器套接字。
2. 等待客户端连接：通过ServerSocket的accept方法等待并接受客户端的连接请求，这个方法会一直阻塞到一个连接建立。
3. 处理连接：一旦连接建立，accept方法会返回一个Socket对象，通过这个Socket可以与客户端进行通信。
4. 数据交换：使用得到的Socket对象的输入输出流（getInputStream/getOutputStream）与客户端交换数据。
5. 关闭连接：通信完成后，需要关闭Socket和ServerSocket。

示例代码片段（服务端）:

import java.net.ServerSocket;
import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;

public class Server {
    public static void main(String[] args) {
        int port = 12345; // 服务端口号
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("Server is listening on port " + port);
            while (true) {
                Socket socket = serverSocket.accept();
                System.out.println("New client connected");
                
                // 获取输入输出流进行读写操作
                InputStream input = socket.getInputStream();
                OutputStream output = socket.getOutputStream();
                
                // 读写操作...
                
                socket.close(); // 关闭连接
            }
        } catch (IOException e) {
            System.out.println("Server exception: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

客户端 (Client)

客户端程序通常需要执行以下步骤：

1. 连接到服务器：使用Socket类的构造函数，提供服务器的IP地址和端口号来创建一个到服务端的连接。
2. 数据交换：使用Socket对象的输入输出流与服务端交换数据。
3. 关闭连接：通信完成后，需要关闭Socket。

示例代码片段（客户端）:

import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;

public class Client {
    public static void main(String[] args) {
        String host = "127.0.0.1";
        int port = 12345;
        try (Socket socket = new Socket(host, port)) {
            
            System.out.println("Connected to server");
            
            // 获取输入输出流进行读写操作
            InputStream input = socket.getInputStream();
            OutputStream output = socket.getOutputStream();
            
            // 读写操作...
            
        } catch (IOException e) {
            System.out.println("Client exception: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

在实际应用中，服务端通常需要能够处理多个客户端的并发连接，这通常通过多线程（每个连接一个线程）或者非阻塞IO（Java NIO）来实现。

需要注意的是，上面的代码只是演示了创建连接和准备读写操作的基本步骤，实际的读写逻辑（如处理输入输出流中的数据）需要根据具体的应用协议来实现。此外，异常处理、资源管理、安全性和性能优化等方面在真实的应用程序中也是非常重要的。

以下是Java服务端和客户端的一些更具体的例子，这些例子展示了如何建立连接、发送和接收数据，以及处理异常情况。

服务端例子: Echo服务器

这是一个简单的Echo服务器，它将接收到的客户端消息原样返回。

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

public class EchoServer {
    public static void main(String[] args) {
        int port = 55555;
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("Echo Server is listening on port " + port);

            while (true) {
                try (Socket socket = serverSocket.accept()) {
                    System.out.println("New client connected");

                    BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                    
                    String line;
                    while ((line = in.readLine()) != null) {
                        System.out.printf("Received: %s%n", line);
                        out.println(line); // Echo back the received line to the client
                    }
                } catch (IOException e) {
                    System.out.println("Exception caught when trying to listen on port " + port + " or listening for a connection");
                    System.out.println(e.getMessage());
                }
            }
        } catch (IOException e) {
            System.out.println("Server exception: " + e.getMessage());
        }
    }
}

客户端例子: Echo客户端

这是与上述Echo服务器交互的客户端。

import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;

public class EchoClient {
    public static void main(String[] args) {
        String hostname = "127.0.0.1";
        int port = 55555;

        try (Socket socket = new Socket(hostname, port)) {
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));

            String userInput;
            while ((userInput = stdIn.readLine()) != null) {
                out.println(userInput);
                System.out.println("Echo: " + in.readLine());
            }
        } catch (UnknownHostException e) {
            System.err.println("Host unknown: " + hostname);
            System.exit(1);
        } catch (IOException e) {
            System.err.println("I/O error for the connection to: " + hostname);
            System.exit(1);
        }
    }
}

服务端例子: 多线程服务器

这是一个能够处理多个客户端的多线程Echo服务器。

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

public class MultiThreadedEchoServer {
    public static void main(String[] args) {
        int port = 55555;
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("MultiThreaded Echo Server is listening on port " + port);

            while (true) {
                Socket socket = serverSocket.accept();
                System.out.println("New client connected");
                new EchoClientHandler(socket).start(); // 创建新线程来处理连接
            }
        } catch (IOException e) {
            System.out.println("Server exception: " + e.getMessage());
        }
    }
}

class EchoClientHandler extends Thread {
    private Socket clientSocket;

    public EchoClientHandler(Socket socket) {
        this.clientSocket = socket;
    }

    public void run() {
        try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
            
            String line;
            while ((line = in.readLine()) != null) {
                System.out.printf("Received: %s%n", line);
                out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Exception caught when trying to listen on port or listening for a connection");
            System.out.println(e.getMessage());
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                // ignore exception on close
            }
        }
    }
}

请注意，对于生产环境中的多线程服务器，您可能需要使用线程池来限制并发线程的数量，以及处理更复杂的同步和资源管理问题。Java的java.util.concurrent包提供了强大的并发工具，包括线程池。

这些示例均为基本的网络编程场景。在实际开发中，服务端和客户端可能需要实现更复杂的协议和更强大的错误处理机制。在构建真正健壮的网络应用时，需要考虑网络延迟、连接中断、数据格式校验、安全性（如使用SSL/TLS）等方面。此外，还可能需要涉及到序列化（如使用JSON或XML）以及与数据库的交互。