Section 5.10. Networking with java.net

5.10. Networking with java.net

The java.net package defines a number of classes that make writing networked applications surprisingly easy. Various examples follow.

5.10.1. Networking with the URL Class

The easiest networking class to use is URL , which represents a uniform resource locator. Different Java implementations may support different sets of URL protocols, but, at a minimum, you can rely on support for the http:// , ftp:// , and file:// protocols. As of Java 1.4, secure HTTP is also supported with the https :// protocol. Here are some ways you can use the URL class:

 import java.net.*;   import java.io.*;    // Create some URL objects  URL url=null, url2=null, url3=null; try {   url = new URL("http://www.oreilly.com");        // An absolute URL   url2 = new URL(url, "catalog/books/javanut4/"); // A relative URL   url3 = new URL("http:", "www.oreilly.com", "index.html"); } catch (MalformedURLException e) { /* Ignore this exception */ } // Read the content of a URL from an input stream InputStream in = url.openStream(); // For more control over the reading process, get a URLConnection object URLConnection conn = url.openConnection(); // Now get some information about the URL String type = conn.getContentType(); String encoding = conn.getContentEncoding(); java.util.Date lastModified = new java.util.Date(conn.getLastModified()); int len = conn.getContentLength(); // If necessary, read the contents of the URL using this stream InputStream in = conn.getInputStream(); 

5.10.2. Working with Sockets

Sometimes you need more control over your networked application than is possible with the URL class. In this case, you can use a Socket to communicate directly with a server. For example:

 import java.net.*; import java.io.*; // Here's a simple client program that connects to a web server,  // requests a document and reads the document from the server. String hostname = "java.oreilly.com";  // The server to connect to int port = 80;                         // Standard port for HTTP  String filename = "/index.html";       // The file to read from the server Socket s = new Socket(hostname, port); // Connect to the server // Get I/O streams we can use to talk to the server InputStream sin = s.getInputStream(); BufferedReader fromServer = new BufferedReader(new InputStreamReader(sin)); OutputStream sout = s.getOutputStream(); PrintWriter toServer = new PrintWriter(new OutputStreamWriter(sout)); // Request the file from the server, using the HTTP protocol toServer.print("GET " + filename + " HTTP/1.0\r\n\r\n"); toServer.flush(); // Now read the server's response, assume it is a text file, and print it out for(String l = null; (l = fromServer.readLine()) != null; )   System.out.println(l); // Close everything down when we're done toServer.close(); fromServer.close(); s.close(); 

5.10.3. Secure Sockets with SSL

In Java 1.4, the Java Secure Socket Extension, or JSSE, was added to the core Java platform in the packages javax.net and javax.net.ssl . ^[1] This API enables encrypted network communication over sockets that use the SSL (Secure Sockets Layer, also known as TLS) protocol. SSL is widely used on the Internet: it is the basis for secure web communication using the https:// protocol. In Java 1.4 and later, you can use https:// with the URL class as previously shown to securely download documents from web servers that support SSL.

^[1] An earlier version of JSSE using different package names is available as a separate download for use with Java 1.2 and Java 1.3. See http://java.sun.com/products/jsse/.

Like all Java security APIs, JSSE is highly configurable and gives low-level control over all details of setting up and communicating over an SSL socket. The javax.net and javax.net.ssl packages are fairly complex, but in practice, you need only a few classes to securely communicate with a server. The following program is a variant on the preceding code that uses HTTPS instead of HTTP to securely transfer the contents of the requested URL:

 import java.io.*; import java.net.*; import javax.net.ssl.*; import java.security.cert.*; /**  * Get a document from a web server using HTTPS. Usage:  *   java HttpsDownload <hostname> <filename>  **/ public class HttpsDownload {     public static void main(String[] args) throws IOException {         // Get a SocketFactory object for creating SSL sockets         SSLSocketFactory factory =             (SSLSocketFactory) SSLSocketFactory.getDefault();         // Use the factory to create a secure socket connected to the          // HTTPS port of the specified web server.         SSLSocket sslsock=(SSLSocket)factory.createSocket(args[0], // Hostname                                                          443); // HTTPS port         // Get the certificate presented by the web server         SSLSession session = sslsock.getSession();         X509Certificate cert;            try { cert = (X509Certificate)session.getPeerCertificates()[0]; }         catch(SSLPeerUnverifiedException e) { // If no or invalid certificate             System.err.println(session.getPeerHost() +                                " did not present a valid certificate.");             return;         }         // Display details about the certificate         System.out.println(session.getPeerHost() +                             " has presented a certificate belonging to:");         System.out.println("\t[" + cert.getSubjectDN().getName() + "]");         System.out.println("The certificate bears the valid signature of:");         System.out.println("\t[" + cert.getIssuerDN().getName() + "]");         // If the user does not trust the certificate, abort         System.out.print("Do you trust this certificate (y/n)? ");         System.out.flush();         BufferedReader console =             new BufferedReader(new InputStreamReader(System.in));         if (Character.toLowerCase(console.readLine().charAt(0)) != 'y') return;         // Now use the secure socket just as you would use a regular socket         // First, send a regular HTTP request over the SSL socket         PrintWriter out = new PrintWriter(sslsock.getOutputStream());         out.print("GET " + args[1] + " HTTP/1.0\r\n\r\n");         out.flush();         // Next, read the server's response and print it to the console         BufferedReader in =           new BufferedReader(new InputStreamReader(sslsock.getInputStream()));         String line;         while((line = in.readLine()) != null) System.out.println(line);                  // Finally, close the socket         sslsock.close();      } } 

5.10.4. Servers

A client application uses a Socket to communicate with a server. The server does the same thing: it uses a Socket object to communicate with each of its clients . However, the server has an additional task in that it must be able to recognize and accept client connection requests. This is done with the ServerSocket class. The following code shows how you might use a ServerSocket . The code implements a simple HTTP server that responds to all requests by sending back (or mirroring) the exact contents of the HTTP request. A dummy server like this is useful when debugging HTTP clients:

 import java.io.*; import java.net.*; public class HttpMirror {   public static void main(String[] args) {     try {       int port = Integer.parseInt(args[0]);       // The port to listen on       ServerSocket ss = new ServerSocket(port);   // Create a socket to listen       for(;;) {                                   // Loop forever         Socket client = ss.accept();              // Wait for a connection         ClientThread t = new ClientThread(client);// A thread to handle it         t.start();                                // Start the thread running       }                                           // Loop again     }      catch (Exception e) {       System.err.println(e.getMessage());       System.err.println("Usage: java HttpMirror <port>;");     }   }   static class ClientThread extends Thread {     Socket client;     ClientThread(Socket client) { this.client = client; }     public void run() {       try {         // Get streams to talk to the client         BufferedReader in =            new BufferedReader(new InputStreamReader(client.getInputStream()));         PrintWriter out =           new PrintWriter(new OutputStreamWriter(client.getOutputStream()));                  // Send an HTTP response header to the client         out.print("HTTP/1.0 200\r\nContent-Type: text/plain\r\n\r\n");                  // Read the HTTP request from the client and send it right back         // Stop when we read the blank line from the client that marks          // the end of the request and its headers.          String line;         while((line = in.readLine()) != null) {           if (line.length() == 0) break;           out.println(line);         }                  out.close();         in.close();         client.close();       }       catch (IOException e) { /* Ignore exceptions */ }     }   } } 

This server code could be modified using JSSE to support SSL connections. Making a server secure is more complex than making a client secure, however, because a server must have a certificate it can present to the client. Therefore, server-side JSSE is not demonstrated here.

5.10.5. Datagrams

Both URL and Socket perform networking on top of a stream-based network connection. Setting up and maintaining a stream across a network takes work at the network level, however. Sometimes you need a low-level way to speed a packet of data across a network, but you don't care about maintaining a stream. If, in addition, you don't need a guarantee that your data will get there or that the packets of data will arrive in the order you sent them, you may be interested in the DatagramSocket and DatagramPacket classes:

 import java.net.*; // Send a message to another computer via a datagram try {   String hostname = "host.example.com";    // The computer to send the data to   InetAddress address =                    // Convert the DNS hostname     InetAddress.getByName(hostname);       // to a lower-level IP address.    int port = 1234;                         // The port to connect to   String message = "The eagle has landed.";  // The message to send   byte[] data = message.getBytes();          // Convert string to bytes   DatagramSocket s = new DatagramSocket();   // Socket to send message with   DatagramPacket p =                         // Create the packet to send     new DatagramPacket(data, data.length, address, port);   s.send(p);                                // Now send it!   s.close();                                // Always close sockets when done } catch (UnknownHostException e) {}  // Thrown by InetAddress.getByName() catch (SocketException e) {}       // Thrown by new DatagramSocket() catch (java.io.IOException e) {}   // Thrown by DatagramSocket.send() // Here's how the other computer can receive the datagram try {   byte[] buffer = new byte[4096];              // Buffer to hold data      DatagramSocket s = new DatagramSocket(1234); // Socket that receives it                                                 // through   DatagramPacket p =      new DatagramPacket(buffer, buffer.length); // The packet that receives it   s.receive(p);                                // Wait for a packet to arrive   String msg =                                 // Convert the bytes from the     new String(buffer, 0, p.getLength());      // packet back to a string.    s.close();                                   // Always close the socket } catch (SocketException e) {}       // Thrown by new DatagramSocket() catch (java.io.IOException e) {}   // Thrown by DatagramSocket.receive() 

5.10.6. Testing the Reachability of a Host

In Java 5.0 the InetAddress class has an isReachable( ) method that attempts to determine whether the host is reachable . The following code uses it in a naive Java implementation of the Unix ping utility:

 import java.io.IOException; import java.net.InetAddress; import java.net.UnknownHostException; public class Ping {     public static void main(String[] args) throws IOException {         try {             String hostname = args[0];             int timeout = (args.length > 1)?Integer.parseInt(args[1]):2000;             InetAddress[] addresses = InetAddress.getAllByName(hostname);             for(InetAddress address : addresses) {                 if (address.isReachable(timeout))                     System.out.printf("%s is reachable%n", address);                 else                     System.out.printf("%s could not be contacted%n", address);             }         }         catch (UnknownHostException e) {             System.out.printf("Unknown host: %s%n", args[0]);         }         catch(IOException e) { System.out.printf("Network error: %s%n", e); }         catch (Exception e) {              // ArrayIndexOutOfBoundsException or NumberFormatException             System.out.println("Usage: java Ping <hostname> [timeout in ms]");         }     } }