Computers can be connected with each other through a variety of physical media. In a computer lab, for example, computers are connected by network cabling. Electrical impulses representing information flow across the cables. If you use a DSL modem to connect your computer to the Internet, the signals travel across a regular telephone wire, encoded as tones. On a wireless network, signals are sent by transmitting a modulated radio frequency. The physical characteristics of these transmissions differ widely, but they ultimately consist of sending and receiving streams of zeroes and ones along the network connection.

These zeroes and ones represent two kinds of information: application data, the data that one computer actually wants to send to another, and network protocol data, the data that describe how to reach the intended recipient and how to check for errors and data loss in the transmission. The protocol data follow certain rules set forth by a particular network protocol. Various protocols have been developed for local area networks, such as Microsoft Networking, Novell NetWare, or Apple-Talk. The Internet Protocol (IP), on the other hand, was developed to enable different local area networks to communicate with each other and has become the basis for connecting computers around the world over the Internet. We will discuss IP in this chapter.

Suppose that a computer A wants to send data to a computer B, both on the Internet. The computers aren't connected directly with a cable, as they could be if both were on the same local area network. Instead, A may be someone's home computer and connected to an Internet service provider (ISP), which is in turn connected to an Internet access point; B might be a computer on a local area network belonging to a large firm that has an Internet access point of its own, which may be half a world away from A. The Internet itself, finally, is a complex collection of pathways on which a message can travel from one Internet access point to, eventually, any other Internet access point (see Figure 1). Those connections carry millions of messages, not just the data that A is sending to B.

For the data to arrive at its destination, it must be marked with a destination address. In IP, addresses are denoted by sequences of four numbers, each one byte (that is, between 0 and 255); for example, 130.65.86.66. (Because there aren't enough four-byte addresses for all devices that would like to connect to the Internet, these addresses will be extended to sixteen bytes in the near future.) In order to send data, A needs to know the Internet address of B and include it in the protocol portion when sending the data across the Internet. The routing software that is distributed across the Internet can then deliver the data to B.

Figure 21.1. Two Computers Communicating Across the Internet

Of course, addresses such as 130.65.86.66 are not easy to remember. You would not be happy if you had to use number sequences every time you sent e-mail or requested information from a web server. On the Internet, computers can have so-called domain names that are easier to remember, such as cs.sjsu.edu or horstmann.com. A special service called the Domain Naming Service (DNS) translates between domain names and Internet addresses. Thus, if computer A wants to have information from horstmann.com, it first asks the DNS to translate this domain name into a numeric Internet address; then it includes the numeric address with the request.

One interesting aspect of IP is that it breaks large chunks of data up into more manageable packets. Each packet is delivered separately, and different packets that are part of the same transmission can take different routes through the Internet. Packets are numbered, and the recipient reassembles them in the correct order.

The Internet Protocol has just one function—to attempt to deliver data from one computer to another across the Internet. If some data get lost or garbled in the process, IP has safeguards built in to make sure that the recipient is aware of that unfortunate fact and doesn't rely on incomplete data. However, IP has no provision for retrying an incomplete transmission. That is the job of a higher-level protocol, the Transmission Control Protocol (TCP). This protocol attempts reliable delivery of data, with retries if there are failures, and it notifies the sender whether or not the attempt succeeded. Most, but not all, Internet programs use TCP for reliable delivery. (Exceptions are "streaming media" services, which bypass the slower TCP for the highest possible throughput and tolerate occasional information loss. However, the most popular Internet services—the World Wide Web and e-mail—use TCP.) TCP is independent of the Internet Protocol; it could in principle be used with another lower-level network protocol. However, in practice, TCP over IP (often called TCP/IP) is the most commonly used combination. We will focus on TCP/IP networking in this chapter.

A computer that is connected to the Internet may have programs for many different purposes. For example, a computer may run both a web server program and a mail server program. When data are sent to that computer, they need to be marked so that they can be forwarded to the appropriate program. TCP uses port numbersfor this purpose. A port number is an integer between 0 and 65,535. The sending computer must know the port number of the receiving program and include it with the transmitted data. Some applications use "well-known" port numbers. For example, by convention, web servers use port 80, whereas mail servers running the Post Office Protocol (POP) use port 110. TCP packets, therefore, must contain

You can think of a TCP connection as a "pipe" between two computers that links the two ports together. Data flow in either direction through the pipe. In practical programming situations, you simply establish a connection and send data across it without worrying about the details of the TCP/IP mechanism. You will see how to establish such a connection in Section 21.3.

Why do some streaming media services not use TCP?

In the preceding section you saw how the TCP/IP mechanism can establish an Internet connection between two ports on two computers so that the two computers can exchange data. Each Internet application has a different application protocol, which describes how the data for that particular application are transmitted.

Consider, for example, HTTP: the Hypertext Transfer Protocol, which is used for the World Wide Web. Suppose you type a web address, called a Uniform Resource Locator (URL, often pronounced like "Earl"), such as http://horstmann.com/index.html, into the address window of your browser and ask the browser to load the page.

The browser now takes the following steps:

You can try the following experiment to see this process in action. The "Telnet" program enables a user to type characters for sending to a remote computer and view characters that the remote computer sends back. On Windows, you need to enable the Telnet program in the control panel. UNIX, Linux, and Mac OS X systems normally have Telnet preinstalled.

For this experiment, you want to start Telnet with a host of horstmann.com and port 80. To start the program from the command line, simply type

telnet horstmann.com 80

Once the program starts, type very carefully, without making any typing errors and without hitting the backspace key,

GET / HTTP/1.1
Host: horstmann.com

Then hit the Enter key twice.

The first / denotes the root page of the web server. Note that there are spaces before and after the first /, but there are no spaces in HTTP/1.1.

On Windows, you will not see what you type, so you should be extra careful when typing in the commands.

The server now sends a response to the request—see Figure 2. The response, of course, consists of the root web page that you requested. The Telnet program is not a browser and does not understand HTML tags, so it simply displays the HTML file—text, tags, and all.

The GET command is one of the commands of HTTP. Table 1 shows the other commands of the protocol. As you can see, the protocol is pretty simple.

By the way, be sure not to confuse HTML with HTTP. HTML is a document format (with commands such as <h1> or <ul>) that describes the structure of a document, including headings, bulleted lists, images, hyperlinks, and so on. HTTP is a protocol (with commands such as GET and POST) that describes the command set for web server requests. Web browsers know how to display HTML documents and how to issue HTTP commands. Web servers know nothing about HTML. They merely understand HTTP and know how to fetch the requested items. Those items may be HTML documents, GIF or JPEG images, or any other data that a web browser can display.

Figure 21.2. Using Telnet to Connect to a Web Server

Figure 21.3. A Sample POP Session

HTTP is just one of many application protocols in use on the Internet. Another commonly used protocol is the Post Office Protocol (POP), which is used to download received messages from e-mail servers. To send messages, you use yet another protocol called the Simple Mail Transfer Protocol (SMTP). We don't want to go into the details of these protocols, but Figure 3 gives you a flavor of the commands used by the Post Office Protocol.

Both HTTP and POP use plain text, which makes it particularly easy to test and debug client and server programs (see How To 21.1 on page 855).

Why is it important that you don't make typing errors when you type HTTP commands in Telnet?

In this section you will see how to write a Java program that establishes a TCP connection to a server, sends a request to the server, and prints the response.

In the terminology of TCP/IP, there is a socket on each side of the connection (see Figure 4). In Java, a client establishes a socket with a call

Socket s = new Socket(hostname, portnumber);

For example, to connect to the HTTP port of the server horstmann.com, you use

final int HTTP_PORT = 80;
Socket s = new Socket("horstmann.com", HTTP_PORT);

The socket constructor throws an UnknownHostException if it can't find the host.

Once you have a socket, you obtain its input and output streams:

InputStream instream = s.getInputStream();
OutputStream outstream = s.getOutputStream();

Figure 21.4. Client and Server Sockets

When you send data to outstream, the socket automatically forwards it to the server. The socket catches the server's response, and you can read the response through instream (see Figure 4).

When you are done communicating with the server, you should close the socket:

s.close();

In Chapter 19, you saw that the InputStream and OutputStream classes are used for reading and writing bytes. If you want to communicate with the server by sending and receiving text, you should turn the streams into scanners and writers, as follows:

Scanner in = new Scanner(instream);
PrintWriter out = new PrintWriter(outstream);

A print writer buffers the characters that you send to it. That is, characters are not immediately sent to their destination. Instead, they are placed into an array. When the array is full, then the print writer sends all characters in the array to its destination. The advantage of buffering is increased performance—it takes some amount of time to contact the destination and send it data, and it is expensive to pay for that contact time for every character. However, when communicating with a server that responds to requests, you want to make sure that the server gets a complete request at a time. Therefore, you need to flush the buffer manually whenever you send a command:

out.print(command);
out.flush();

The flush method empties the buffer and forwards all waiting characters to the destination.

The WebGet program at the end of this section lets you retrieve any item from a web server. You need to specify the host and the item from the command line. For example,

java WebGet horstmann.com /

The / item denotes the root page of the web server that listens to port 80 of the host horstmann.com. Note that there is a space before the /.

The program simply establishes a connection to the host, sends a GET command to the host, and then receives input from the server until the server closes its connection.

ch21/webget/WebGet.java

1  import java.io.InputStream;
 2  import java.io.IOException;
 3  import java.io.OutputStream;
 4  import java.io.PrintWriter;
 5  import java.net.Socket;
 6  import java.util.Scanner;
 7
 8  /**
 9     This program demonstrates how to use a socket to communicate
10     with a web server. Supply the name of the host and the
11     resource on the command-line, for example,
12     java WebGet horstmann.com index.html.
13  */
14  public class WebGet
15  {
16     public static void main(String[] args) throws IOException
17     {
18        // Get command-line arguments
19
20        String host;
21        String resource;
22
23        if (args.length == 2)
24        {
25           host = args[0];
26           resource = args[1];
27        }
28        else
29        {
30           System.out.println("Getting / from horstmann.com");
31           host = "horstmann.com";
32           resource = "/";
33        }
34
35        // Open socket
36
37        final int HTTP_PORT = 80;
38        Socket s = new Socket(host, HTTP_PORT);
39
40        // Get streams
41
42        InputStream instream = s.getInputStream();
43        OutputStream outstream = s.getOutputStream();
44
45        // Turn streams into scanners and writers
46
47        Scanner in = new Scanner(instream);
48        PrintWriter out = new PrintWriter(outstream);
49
50        // Send command
51
52        String command = "GET " + resource + " HTTP/1.1
"
53              + "Host: " + host + "

";
54        out.print(command);

55        out.flush();
56
57        // Read server response
58
59        while (in.hasNextLine())
60        {
61           String input = in.nextLine();
62           System.out.println(input);
63        }
64
65        // Always close the socket at the end
66
67        s.close();
68       }
69    }

Program Run

Getting / from horstmann.com
HTTP/1.1 200 OK
Date: Thu, 17 Sep 2009 14:15:04 GMT
Server: Apache/1.3.41 (Unix) Sun-ONE-ASP/4.0.2
...
Content-Length: 6654
Content-Type: text/html

<html>
<head><title>Cay Horstmann's Home Page</title></head>
<body>
<h1>Welcome to Cay Horstmann's Home Page</h1>
...
</body>
</html>

6. How do you open a socket to read e-mail from the POP server at e-mail.sjsu.edu?

Now that you have seen how to write a network client, we will turn to the server side. In this section we will develop a server program that enables clients to manage a set of bank accounts in a bank.

Whenever you develop a server application, you need to specify some application-level protocol that clients can use to interact with the server. For the purpose of this example, we will create a "Simple Bank Access Protocol". Table 2 shows the protocol format. Of course, this is just a toy protocol to show you how to implement a server.

The server program waits for clients to connect to a particular port. We choose port 8888 for this service. This number has not been preassigned to another service, so it is unlikely to be used by another server program. To listen to incoming connections, you use a server socket. To construct a server socket, you need to supply the port number.

ServerSocket server = new ServerSocket(8888);

The accept method of the ServerSocket class waits for a client connection. When a client connects, then the server program obtains a socket through which it communicates with the client.

Socket s = server.accept();
BankService service = new BankService(s, bank);

The BankService class carries out the service. This class implements the Runnable inter-face, and its run method will be executed in each thread that serves a client connection. The run method gets a scanner and writer from the socket in the same way as we discussed in the preceding section. Then it executes the following method:

public void doService() throws IOException
{
   while (true)
   {
      if (!in.hasNext()) return;
      String command = in.next();
      if (command.equals("QUIT")) return;
      executeCommand(command);
   }
}

The executeCommand method processes a single command. If the command is DEPOSIT, then it carries out the deposit.

int account = in.nextInt();
double amount = in.nextDouble();
bank.deposit(account, amount);

The WITHDRAW command is handled in the same way. After each command, the account number and new balance are sent to the client:

out.println(account + " " + bank.getBalance(account));

The doService method returns to the run method if the client closed the connection or the command equals "QUIT". Then the run method closes the socket and exits.

Let us go back to the point where the server socket accepts a connection and constructs the BankService object. At this point, we could simply call the run method.

But then our server program would have a serious limitation: only one client could connect to it at any point in time. To overcome that limitation, server programs spawn a new thread whenever a client connects. Each thread is responsible for serving one client.

Our BankService class implements the Runnable interface. Therefore, the server program simply starts a thread with the following instructions:

Thread t = new Thread(service);
t.start();

The thread dies when the client quits or disconnects and the run method exits. In the meantime, the BankServer loops back to accept the next connection.

while (true)
{
   Socket s = server.accept();
   BankService service = new BankService(s, bank);
   Thread t = new Thread(service);
   t.start();
}

The server program never stops. When you are done running the server, you need to kill it. For example, if you started the server in a shell window, hit Ctrl+C.

To try out the program, run the server. Then use Telnet to connect to localhost, port number 8888. Start typing commands. Here is a typical dialog (see Figure 5):

DEPOSIT 3 1000
3 1000.0
WITHDRAW 3 500
3 500.0
QUIT

Alternatively, you can use a client program that connects to the server. You will find a sample client program at the end of this section.

Figure 21.5. Using the Telnet Program to Connect to the Bank Server

ch21/bank/BankServer.java

1  import java.io.IOException;
 2  import java.net.ServerSocket;
 3  import java.net.Socket;
 4
 5  /**
 6     A server that executes the Simple Bank Access Protocol.
 7  */
 8  public class BankServer
 9  {
10     public static void main(String[] args) throws IOException
11     {
12        final int ACCOUNTS_LENGTH = 10;
13        Bank bank = new Bank(ACCOUNTS_LENGTH);
14        final int SBAP_PORT = 8888;
15        ServerSocket server = new ServerSocket(SBAP_PORT);
16        System.out.println("Waiting for clients to connect ... ");
17
18        while (true)
19        {
20           Socket s = server.accept();
21           System.out.println("Client connected.");
22           BankService service = new BankService(s, bank);
23           Thread t = new Thread(service);
24           t.start();
25        }
26     }
27  }

ch21/bank/BankService.java

1  import java.io.InputStream;
 2  import java.io.IOException;
 3  import java.io.OutputStream;
 4  import java.io.PrintWriter;
 5  import java.net.Socket;
 6  import java.util.Scanner;
 7
 8  /**
 9    Executes Simple Bank Access Protocol commands
10    from a socket.
11 */
12 public class BankService implements Runnable
13 {
14    private Socket s;
15    private Scanner in;
16    private PrintWriter out;
17    private Bank bank;
18
19    /**
20       Constructs a service object that processes commands
21       from a socket for a bank.
22       @param aSocket the socket
23       @param aBank the bank
24    */
25    public BankService(Socket aSocket, Bank aBank)
26    {

27       s = aSocket;
28       bank = aBank;
29    }
30
31    public void run()
32    {
33       try
34       {
35          try
36          {
37             in = new Scanner(s.getInputStream());
38             out = new PrintWriter(s.getOutputStream());
39             doService();
40          }
41          finally
42          {
43             s.close();
44          }
45    }
46          catch (IOException exception)
47        {
48          exception.printStackTrace();
49        }
50     }
51
52     /**
53       Executes all commands until the QUIT command or the
54       end of input.
55     */
56        public void doService() throws IOException
57     {
58        while (true)
59        {
60          if (!in.hasNext()) return;
61          String command = in.next();
62          if (command.equals("QUIT")) return;
63          else executeCommand(command);
64        }
65     }
66
67     /**
68          Executes a single command.
69          @param command the command to execute
70     */
71          public void executeCommand(String command)
72     {
73          int account = in.nextInt();
74          if (command.equals("DEPOSIT"))
75          {
76             double amount = in.nextDouble();
77             bank.deposit(account, amount);
78          }
79          else if (command.equals("WITHDRAW"))
80          {
81             double amount = in.nextDouble();
82             bank.withdraw(account, amount);

83          }
84          else if (!command.equals("BALANCE"))
85          {
86             out.println("Invalid command");
87             out.flush();
88             return;
89          }
90          out.println(account + " " + bank.getBalance(account));
91          out.flush();
92       }
93    }

ch21/bank/Bank.java

1  /**
 2     A bank consisting of multiple bank accounts.
 3  */
 4  public class Bank
 5  {
 6     private BankAccount[] accounts;
 7
 8     /**
 9        Constructs a bank account with a given number of accounts.
10        @param size the number of accounts
11     */
12     public Bank(int size)
13     {
14        accounts = new BankAccount[size];
15        for (int i = 0; i < accounts.length; i++)
16           accounts[i] = new BankAccount();
17     }
18
19     /**
20        Deposits money into a bank account.
21        @param accountNumber the account number
22        @param amount the amount to deposit
23     */
24     public void deposit(int accountNumber, double amount)
25     {
26        BankAccount account = accounts[accountNumber];
27        account.deposit(amount);
28     }
29
30     /**
31        Withdraws money from a bank account.
32        @param accountNumber the account number
33        @param amount the amount to withdraw
34     */
35     public void withdraw(int accountNumber, double amount)
36     {
37        BankAccount account = accounts[accountNumber];
38        account.withdraw(amount);
39     }
40

41     /**
42        Gets the balance of a bank account.
43        @param accountNumber the account number
44        @return the account balance
45     */
46     public double getBalance(int accountNumber)
47     {
48        BankAccount account = accounts[accountNumber];
49        return account.getBalance();
50     }
51  }

ch21/bank/BankClient.java

1  import java.io.InputStream;
 2  import java.io.IOException;
 3  import java.io.OutputStream;
 4  import java.io.PrintWriter;
 5  import java.net.Socket;
 6  import java.util.Scanner;
 7
 8  /**
 9     This program tests the bank server.
10  */
11  public class BankClient
12  {
13     public static void main(String[] args) throws IOException
14     {
15        final int SBAP_PORT = 8888;
16        Socket s = new Socket("localhost", SBAP_PORT);
17        InputStream instream = s.getInputStream();
18        OutputStream outstream = s.getOutputStream();
19        Scanner in = new Scanner(instream);
20        PrintWriter out = new PrintWriter(outstream);
21
22        String command = "DEPOSIT 3 1000
";
23        System.out.print("Sending: " + command);
24        out.print(command);
25        out.flush();
26        String response = in.nextLine();
27        System.out.println("Receiving: " + response);
28
29        command = "WITHDRAW 3 500
";
30        System.out.print("Sending: " + command);
31        out.print(command);
32        out.flush();
33        response = in.nextLine();
34        System.out.println("Receiving: " + response);
35
36        command = "QUIT
";
37        System.out.print("Sending: " + command);
38        out.print(command);
39        out.flush();
40
41        s.close();
42      }
43  }

Program Run

Sending: DEPOSIT 3 1000
Receiving: 3 1000.0
Sending: WITHDRAW 3 500
Receiving: 3 500.0
Sending: QUIT

8.Can you read data from a server socket?

In Section 21.3, you saw how to use sockets to connect to a web server and how to retrieve information from the server by sending HTTP commands. However, because HTTP is such an important protocol, the Java library contains an URLConnection class, which provides convenient support for the HTTP. The URLConnection class takes care of the socket connection, so you don't have to fuss with sockets when you want to retrieve from a web server. As an additional benefit, the URLConnection class can also handle FTP, the file transfer protocol.

The URLConnection class makes it very easy to fetch a file from a web server given the file's URL as a string. First, you construct an URL object from the URL in the familiar format, starting with the http or ftp prefix. Then you use the URL object's openConnection() method to get the URLConnection object itself.

URL u = new URL("http://horstmann.com/index.html");
URLConnection connection = u.openConnection();

Then you call the getInputStream method to obtain an input stream:

InputStream instream = connection.getInputStream();

You can turn the stream into a scanner in the usual way, and read input from the scanner.

The URLConnection class can give you additional useful information. To understand those capabilities, we need to have a closer look at HTTP requests and responses. You saw in Section 21.2 that the command for getting an item from the server is

GET item HTTP/1.1
Host: hostname
blank line

You may have wondered why you need to provide a blank line. This blank line is a part of the general request format. The first line of the request is a command, such as GET or POST. The command is followed by request properties (such as Host:). Some commands—in particular, the POST command—send input data to the server. The reason for the blank line is to denote the boundary between the request property section and the input data section.

A typical request property is If-Modified-Since. If you request an item with

GET item HTTP/1.1
Host: hostname
If-Modified-Since: date
blank line

the server sends the item only if it is newer than the date. Browsers use this feature to speed up redisplay of previously loaded web pages. When a web page is loaded, the browser stores it in a cache directory. When the user wants to see the same web page again, the browser asks the server to get a new page only if it has been modified since the date of the cached copy. If it hasn't been, the browser simply redisplays the cached copy and doesn't spend time downloading another identical copy.

The URLConnection class has methods to set request properties. For example, you can set the If-Modified-Since property with the setIfModifiedSince method:

connection.setIfModifiedSince(date);

You need to set request properties before calling the getInputStream method. The URLConnection class then sends to the web server all the request properties that you set.

Similarly, the response from the server starts with a status line followed by a set of response parameters. The response parameters are terminated by a blank line and followed by the requested data (for example, an HTML page). Here is a typical response:

HTTP/1.1 200 OK
Date: Tue, 24 Aug 2010 00:15:48 GMT
Server: Apache/1.3.3 (Unix)
Last-Modified: Sat, 26 Jun 2010 20:53:38 GMT
Content-Length: 4813
Content-Type: text/html
blank line
requested data

Normally, you don't see the response code. However, you may have run across bad links and seen a page that contained a response code 404 Not Found. (A successful response has status 200 OK.)

To retrieve the response code, you need to cast the URLConnection object to the HttpURLConnection subclass. You can retrieve the response code (such as the number 200 in this example, or the code 404 if a page was not found) and response message with the getResponseCode and getResponseMessage methods:

HttpURLConnection httpConnection = (HttpURLConnection) connection;
int code = httpConnection.getResponseCode(); // e.g., 404
String message = httpConnection.getResponseMessage(); // e.g., "Not found"

As you can see from the response example, the server sends some information about the requested data, such as the content length and the content type. You can request this information with methods from the URLConnection class:

int length = connection.getContentLength();
String type = connection.getContentType();

You need to call these methods after calling the getInputStream method.

To summarize: You don't need to use sockets to communicate with a web server, and you need not master the details of the HTTP protocol. Simply use the URLConnection and HttpURLConnection classes to obtain data from a web server, to set request parameters, or to obtain response information.

The program at the end of this section puts the URLConnection class to work. The program fulfills the same purpose as that of Section 21.3—to retrieve a web page from a server—but it works at a higher level of abstraction. There is no longer a need to issue an explicit GET command. The URLConnection class takes care of that. Similarly, the parsing of the HTTP request and response headers is handled transparently to the programmer. Our sample program takes advantage of that fact. It checks whether the server response code is 200. If not, it exits. You can try that out by testing the program with a bad URL, like http://horstmann.com/wombat.html. Then the program prints a server response, such as 404 Not Found.

This program completes our introduction into Internet programming with Java. You have seen how to use sockets to connect client and server programs. You also saw how to use the higher-level URLConnection class to obtain information from web servers.

ch21/urlget/URLGet.java

1  import java.io.InputStream;
 2  import java.io.IOException;
 3  import java.io.OutputStream;
 4  import java.io.PrintWriter;
 5  import java.net.HttpURLConnection;
 6  import java.net.URL;
 7  import java.net.URLConnection;
 8  import java.util.Scanner;
 9
10  /**
11     This program demonstrates how to use an URL connection
12     to communicate with a web server. Supply the URL on
13     the command-line, for example
14     java URLGet http://horstmann.com/index.html.
15  */
16  public class URLGet
17  {
18     public static void main(String[] args) throws IOException
19     {
20        // Get command-line arguments
21
22        String urlString;
23        if (args.length == 1)
24           urlString = args[0];
25        else
26        {
27            urlString = "http://horstmann.com/";
28            System.out.println("Using " + urlString);
29        }
30
31        // Open connection
32
33        URL u = new URL(urlString);
34        URLConnection connection = u.openConnection();
35
36        // Check if response code is HTTP_OK (200)
37
38        HttpURLConnection httpConnection
39               = (HttpURLConnection) connection;
40        int code = httpConnection.getResponseCode();
41        String message = httpConnection.getResponseMessage();
42        System.out.println(code + " " + message);
43        if (code != HttpURLConnection.HTTP_OK)
44           return;
45
46        // Read server response
47
48        InputStream instream = connection.getInputStream();
49        Scanner in = new Scanner(instream);
50

51          while (in.hasNextLine())
52          {
53             String input = in.nextLine();
54             System.out.println(input);
55          }
56       }
57    }

Program Run

Using http://horstmann.com/
200 OK
<html>
<head><title>Cay Horstmann's Home Page</title></head>
<body>
<h1>Welcome to Cay Horstmann's Home Page</h1>
...
</body>
</html>

What happens if you use the URLGet program to request an image (such as http://horstmann.com/cay-tiny.gif)?

Media Resources

• Lab Exercises

HTTP/1.1 200 OK
Date: Tue, 15 Jun 2010 16:10:34 GMT
Server: Apache/1.3.19 (Unix)
Cache-Control: max-age=86400
Expires: Wed, 16 Jun 2010 16:10:34 GMT
Connection: close
Content-Type: text/html

<html><head><title> ... </title></head><body> ... </body></html>

HTTP/1.1 200 OK

http://aa.usno.navy.mil/cgi-bin/aa_moonphases.pl?year=2011