Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Solution for
Programming Exercise 10.5

THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to the following exercise from this on-line Java textbook.

Exercise 10.5: Write a client program for the server from Exercise 10.4. Design a user interface that will let the user do at least two things: Get a list of files that are available on the server and display the list on standard output. Get a copy of a specified file from the server and save it to a local file (on the computer where the client is running).


One possible user interface would be to use a menu, as was done in the solution to Exercise 10.3. For variety, however, I decided on an interface based entirely on the command line. The first command line argument must be the name or IP address of the computer where a copy of the FileServer program from Exercise 10.4 is running. If that is the only command-line argument, then the client will contact the server and send an "index" command to the server. The server responds with a list of file names. The client reads these names and displays them on the screen. The program then ends. (If you want to give another command, you have to run the client program again with a new command line.)

If there are two command-line arguments, then the second argument must be the name of a file on the server. The client contacts the server and sends a "get" command. The server responds with a one-line message, either "error" or "ok". The client reads this message. If the message is "error", indicating that the requested file can't be sent, then the client just displays an error message to the user. If the message is "ok", then the server also sends the contents of the file. The client tries to create a local file of the same name. It reads the data from the server and saves it to that file. However, for safety, the client will not create a new file if a local file of the same name already exists. This is considered to be an error. (There was no particular reason to do things this way -- I just wanted to make my interface a bit fancier.)

Finally, I wanted to make it possible to save a downloaded file in a local file with a different name. For this, three command line arguments are used. The first is the server, the second is the name of the file on the server, and the third is the name of the local file where the downloaded file is to be saved. In this case, the program is willing to overwrite an existing file of the same name, so the command must be used with some care.

If the server program is running on the same computer as the client (for demonstration purposes), the the following command lines can be used to run the client:

      java FileClient
      java FileClient  datafile.txt
      java FileClient  datafile.txt  mycopy.dat
      java FileClient  datafile.txt  datafile.txt

The first command shows a list of files that are available on the server. The other three all try to get a file named "datafile.txt" from the server.

The actual programming of the client is fairly straightforward. The example program provides a model for opening a connection to the server and for sending and receiving data over the connection. You should be able to follow the solution, given below.

By the way, once you understand how the FileClient and FileServer examples work, it's not a big conceptual leap to understanding how the World Wide Web works. A Web server program is just a greatly souped-up version of the FileServer program. It has access to a collection of files. It receives and responds to requests for those files from client programs. To get a file, the client program -- a Web browser -- needs to know the computer on which the server is running and the name of the file. This information is encoded in the url address of a Web page -- just like it's given on the command line of the FileClient program. A Web page, of course, can contain links to other Web pages. The link includes a url with the necessary information for finding the page. To get the page, the Web browser just goes through the same process of contacting the specified server and requesting the specified file. (One big complication is that not all the files on a Web server are text files, so the client needs some way of knowing what type of data is stored in the file, and it needs to know how to handle data of that type.)

The Solution

       This program is a client for the FileServer server.  The
       server has a list of available text files that can be
       downloaded by the client.  The client can also download
       the list of files.  When the connection is opened, the
       client sends one of two possible commands to the server:
       "index" or "get <file-name>".  The server replies to
       the first command by sending the list of available files.
       It responds to the second with a one-line message,
       either "ok" or "error".  If the message is "ok", it is
       followed by the contents of the file with the specified
       name.  The "error" message indicates that the specified
       file does not exist on the server.  (The server can also
       respond with the message "unknown command" if the command
       it reads is not one of the two possible legal commands.)
       The client program works with command-line arguments.
       The first argument must be the name or IP address of the
       computer where the server is running.  If that is the
       only argument on the command line, then the client
       gets the list of files from the server and displays
       it on standard output.  If there are two parameters,
       the second parameter is interpreted as the name of a
       file to be downloaded.  A copy of the file is saved
       as a local file of the same name, unless a file of
       the same name already exists.  If there are three
       arguments, the second is the name of the file to be
       downloaded and the third is the name under which the
       local copy of the file is to be saved.  This will
       work even if a file of the same name already exists.
       This program uses the non-standard class, TextReader.
   public class FileClient {
      static final int LISTENING_PORT = 3210;
      public static void main(String[] args) {
         String computer;      // Name or IP address of server.
         Socket connection;    // A socket for communicating with
                               //                that computer.
         PrintWriter outgoing; // Stream for sending a command
                               //                to the server.
         TextReader incoming;  // Stream for reading data from
                               //                the connection.
         String command;       // Command to send to the server.
         /* Check that the number of command-line arguments is legal.
            If not, print a usage message and end. */
         if (args.length == 0 || args.length > 3) {
            System.out.println("Usage:  java FileClient <server>");
            System.out.println("    or  java FileClient <server> <file>");
                  "    or  java FileClient <server> <file> <local-file>");
         /* Get the server name and the message to send to the server. */
         computer = args[0];
         if (args.length == 1)
            command = "index";
            command = "get " + args[1];
         /* Make the connection and open streams for communication.
            Send the command to the server.  If something fails
            during this process, print an error message and end. */
         try {
            connection = new Socket( computer, LISTENING_PORT );
            incoming = new TextReader( connection.getInputStream() );
            outgoing = new PrintWriter( connection.getOutputStream() );
         catch (Exception e) {
                 "Can't make connection to server at \"" + args[0] + "\".");
            System.out.println("Error:  " + e);
         /* Read and process the server's response to the command. */
         try {
            if (args.length == 1) {
                  // The command was "index".  Read and display lines
                  // from the server until the end-of-stream is reached.
               System.out.println("File list from server:");
               while (incoming.eof() == false) {
                  String line = incoming.getln();
                  System.out.println("   " + line);
            else {
                  // The command was "get <file-name>".  Read the server's
                  // response message.  If the message is "ok", get the file.
               String message = incoming.getln();
               if (! message.equals("ok")) {
                  System.out.println("File not found on server.");
               PrintWriter fileOut;  // For writing the received data to a file.
               if (args.length == 3) {
                     // Use the third parameter as a file name.
                   fileOut = new PrintWriter( new FileWriter(args[2]) );
               else {
                     // Use the second parameter as a file name,
                     // but don't replace an existing file.
                   File file = new File(args[1]);
                   if (file.exists()) {
                      System.out.println("A file with that name already exists.");
                      System.out.println("To replace it, use the three-argument");
                      System.out.println("version of the command.");
                   fileOut = new PrintWriter( new FileWriter(args[1]) );
               while (incoming.peek() != '\0') {
                      // Copy lines from incoming to the file until
                      // the end of the incoming stream is encountered.
                   String line = incoming.getln();
               if (fileOut.checkError()) {
                  System.out.println("Some error occurred while writing the file.");
                  System.out.println("Output file might be empty or incomplete.");
         catch (Exception e) {
            System.out.println("Sorry, an error occurred while reading data from the server.");
            System.out.println("Error: " + e);
      }  // end main()
   } //end class FileClient

[ Exercises | Chapter Index | Main Index ]

  Published under free license. Design by Interspire