Java's Socket programming is suitable for building TCP or UDP-based network applications. 1. ServerSocket and Socket are used for TCP to ensure reliable connections; 2. DatagramSocket is used for UDP, suitable for scenarios with high real-time requirements. When writing a TCP application, the server listens and accepts connections through ServerSocket, and the client connects actively through Socket. To handle multiple clients, concurrent connections can be managed using threads or thread pools. Notes include avoiding port conflicts, handling exceptions, closing resources and setting timeouts to ensure program stability and efficiency.

Java's Socket programming is the basis for building network applications, and is especially suitable for scenarios where underlying communication control is required. If you want to use Java to build a network application based on TCP or UDP, Socket is a core technology that cannot be avoided.

Understand Socket Types in Java

Java provides two main Socket types: ServerSocket and Socket (for TCP), and DatagramSocket (for UDP). TCP is a connection-oriented and reliable protocol that is suitable for scenarios where data integrity is required; UDP is lighter and suitable for situations where real-time requirements are high, such as audio and video transmission.

• TCP related categories :
  • ServerSocket : Used to listen to client connections on the server.
  • Socket : represents the connection between the client and the server.
• UDP related categories :
  • DatagramSocket : Send and receive packets.
  • DatagramPacket : Encapsulates the data to be sent or received.

Understanding the basic uses of these classes is a prerequisite for starting to write code.

Write a simple TCP server and client

Building a TCP application usually includes two parts: the server waits for connection and the client actively connects.

Server-side steps:

1. Create ServerSocket and bind the port.
2. Call accept() method to wait for the client to connect.
3. Get input and output streams and read and write data.
4. Close the connection.

 ServerSocket serverSocket = new ServerSocket(8080);
Socket socket = serverSocket.accept();
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(in.readLine());

Client steps:

1. Creates Socket connection to the specified address and port.
2. Get the output stream and send data.
3. Close the connection.

 Socket socket = new Socket("localhost", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello Server");

Although the example above is simple, it shows the basic process of establishing connections and communications.

Handle multi-client connections

By default, ServerSocket can only handle one client connection. If you want to support multiple clients at the same time, you need to introduce a threading mechanism.

A common practice is to start a new thread to handle the connection whenever a new connection comes:

 while (true) {
    Socket socket = serverSocket.accept();
    new Thread(() -> {
        try {
            // Process client request} catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

This allows the server to continuously listen for new connections without being blocked by the operation of a certain client. Note that thread management issues should be considered here, such as using thread pools to avoid resource exhaustion.

In addition, it is also possible to consider using Selector in NIO (Non-blocking IO) to implement a more efficient concurrency model, but this requires more complex logical design.

Notes and FAQs

• Port conflict : Make sure that the port number you are using is not occupied by other programs.
• Exception handling : Network operations are prone to errors, be sure to catch and handle IOException .
• Close resources : After each communication is completed, remember to close Socket and related streams, otherwise it may cause resource leakage.
• Timeout setting : You can set the connection timeout time for Socket to prevent indefinite waiting.

For example, setting the connection timeout:

 Socket socket = new Socket();
socket.connect(new InetSocketAddress("example.com", 80), 5000);

This will attempt to connect within 5 seconds, and an exception will be thrown if it fails.

Basically that's it. Although Java's Socket programming seems basic, it is very practical in actual development. As long as you master the basic processes and precautions, you can write a stable-operating network application.

The above is the detailed content of Building Network Applications with Java Sockets. For more information, please follow other related articles on the PHP Chinese website!