Java Socket Programming in Client/Server Applications - 转自 http://www.developer.com/

原文出处:http://www.developer.com/java/article.php/10922_3840466_1/Java-Socket-Programming-in-ClientServer-Applications.htm

In client/server applications, the client and server components usually do not reside on the same computer (i.e., the client could be installed on a computer that is different from the one hosting the server installation); yet logically they are components of the same application. To enable the client and server components to communicate with each other over a network, systems often rely heavily on sockets.

Because Java provides the required capabilities for developing socket-based applications relatively easily and hides all the complexity involved, Java developers have an advantage in providing quick solutions to networking problems.

The ServerSocket and Socket Classes

Java supports socket development through the java.net package. In particular, ServerSocket and Socket are the socket-related classes. They provide infrastructure for server and client development, respectively. This article explores these classes—and how to use them—in more detail.

You use the ServerSocket class on the server component, where it listens for incoming requests. ServerSocket generally is bound to a port, always active, and non-blocking. This means that it immediately transfers or hands over any incoming request to a different component and then continues listening for new incoming requests. 

To connect with the server component, the client component simply requests a connection to the computer where it expects the server to be running. It includes the computer name and the port to which the server is bound in this request. The resulting connection is permanent for the client; it will not be shared with any other instance of the client software running on the same machine.

Confused? Here is the concept in a nutshell:

   1. The server listens on the port to which it is bound and waits for incoming requests.

   2. When it receives a connection request, it creates a socket and associates the new connection to that socket.

   3. From then on, the client will communicate with the server via this newly created socket (although it is not aware of it). 

Imagine achieving this setup using native code. It would be a lot of work, and if you weren't aware of the low-level constraints (like many developers), you would end up producing poor quality code. Luckily, the Java socket APIs are well tested and used by a large group of developers, which ensures that all possible hidden issues are caught and addressed. That is why developers using Java can produce high-quality client/server applications based on sockets. 

Writing the Server Using Sockets

Code Listing 1 provides a Java example for writing a server component using sockets. In this code, the server binds itself with a ServerSocket on to a pre-determined port. This port will be the one to which clients can request connections. The server then awaits client connection requests on the ServerSocket. When it receives them, it will create a new socket and hand the connection over to it.

The code uses the accept() method on the ServerSocket class, designating the socket as the one responsible for communication with the client. All information to and from the client will be sent and received via this socket. The getInputStream() and getOutputStream() methods are used for the communication with the client.

Figure 1 shows a screenshot of the server console when it starts. 

Figure 1. The Server Console When It Starts:

Here is a screenshot of the server console when it starts.

Writing the Client Using Sockets

Code Listing 2 provides a Java example for writing a client component using sockets.

In this code, the client inputs the server name and the port through which it deliver arguments for creating a socket connection. When the socket is created successfully, it can then talk to the server with the input/output streams. The exception handling has to be effective to pinpoint any problems in the connection.

Figure 2 shows a screenshot of the server console when the client starts, Figure 3 shows a screenshot of the client console, Figure 4 shows a screenshot of the server console when the client starts communicating, and Figure 5 shows a screenshot of the client console during communication. 

Figure 2. Server Console When the Client Starts:

Here is a screenshot of the server console when the client starts.

Figure 3. The Client Console:

Here is a screenshot of the client console.

Figure 4. The Server Console When the Client Starts Communicating:

Here is a screenshot of the server console when the client starts communicating.

Figure 5. The Client Console During Communication:

Here is a screenshot of the client console during communication.

As you start using the application, you can think of numerous enhancements to this example.

Care and Feeding of Your Applications

It is important to close all open resources, such as file handlers, socket connections, and any other open entities because these will lead to memory-leak issues in the long run.

源码:

import java.io.*; import java.net.*; public class ServerUsingSockets { //Declaring variables ServerSocket serverSocket = null; Socket connectionSocket = null; final int PORT_NUMBER = 3500; PrintWriter printWriter = null; BufferedReader bufferedReader = null; String userInput; public static void main(String args[]) throws IOException { ServerUsingSockets serverUsingSockets = new ServerUsingSockets(); serverUsingSockets.start(); } private void start() throws IOException { try { //Listens here serverSocket = new ServerSocket(PORT_NUMBER); printMessage("Server started. Awaiting connection requests..."); } catch(IOException ioexception) { //handle the exception //maybe you want to inform the user that there is a problem and exit here? printMessage("There is a problem starting the Server."); printMessage("Exception: "+ioexception); stopServer(1); } try { //Creates a socket for a client request connectionSocket = serverSocket.accept(); printMessage("Server accepted connection from client."); } catch (IOException ioexception) { //there is a problem creating the connection socket that will //be used by the Client to communicate } printWriter = new PrintWriter(connectionSocket.getOutputStream(), true); bufferedReader = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream())); //This is the input being captured from the client while ((userInput = bufferedReader.readLine()) != null) { printMessage("Received from client: "+userInput); printWriter.println("Server responding with: "+userInput); //you can use your message to respond from server if (userInput.equalsIgnoreCase("Exit") || userInput.equalsIgnoreCase("Bye") || userInput.equalsIgnoreCase("Quit")) { //breaking here. But you can retain until there is a user-intervention to stop the server break; } } printMessage("Server stopped."); closeAllOpenStuff(); } private void printMessage(String message) { System.out.println(message); } private void closeAllOpenStuff() throws IOException { printWriter.close(); bufferedReader.close(); connectionSocket.close(); serverSocket.close(); } private void stopServer(int exitValue) { printMessage("Exiting Server process."); System.exit(exitValue); } }  

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket; import java.net.UnknownHostException; public class ClientUsingSockets { //Declaring variables Socket connectionSocket = null; PrintWriter printWriter = null; BufferedReader bufferedReader = null ,clientInputReader = null; final int PORT_NUMBER = 3500; final String SERVER_NAME = "localhost"; String serverResponse; public static void main(String args[]) throws IOException { ClientUsingSockets clientUsingSockets = new ClientUsingSockets(); clientUsingSockets.start(); } private void start() throws IOException { try { //Connection to Server connectionSocket = new Socket(SERVER_NAME, PORT_NUMBER); printWriter = new PrintWriter(connectionSocket.getOutputStream(), true); bufferedReader = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream())); printMessage("Connected to server."); }catch(UnknownHostException unknownHostException) { printMessage("Host " + SERVER_NAME + " unknown"); stopServer(1); }catch(IOException ioexception) { printMessage("Connection failed to host "+SERVER_NAME); stopServer(1); } clientInputReader = new BufferedReader(new InputStreamReader(System.in)); String clientInput; while ((clientInput = clientInputReader.readLine()) != null) { //Sending the user input to the server printWriter.println(clientInput); if (clientInput.equalsIgnoreCase("Exit") || clientInput.equalsIgnoreCase("Bye") || clientInput.equalsIgnoreCase("Quit")) break; //Reading the response from the server if ((serverResponse = bufferedReader.readLine()) != null) { printMessage(serverResponse); } } closeAllOpenStuff(); } private void printMessage(String message) { System.out.println(message); } private void closeAllOpenStuff() throws IOException { printWriter.close(); bufferedReader.close(); clientInputReader.close(); connectionSocket.close(); } private void stopServer(int exitValue) { printMessage("Exiting Client process."); System.exit(exitValue); } }