Client server help

[jon ladd]

This is a client server program. First you have to laod the server, create a file for the has map to write to then start the client portion. Once the client is running when i type in a name and try to add a name and number it just says invalid number. It not writing from the client server. Any ideas on why it is not doing that would be very helpful.

  //Provides easy access to packaged code.
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;

public class App extends Frame {
  //Private instance variable for the processing mode.
  private int mode;
  //This constructor displays a dialog box from which the user may select the processing mode.
  public App() {
    mode = new OptionDialog(this, "Select Mode", "Server", "Client").choice();
  }
  //This is the main method for the application. It instantiates an App object and,
  //based on the user's choice of processing mode, launches as either a "server" or a "client".
  public static void main(String[] args) {
    App go = new App();
    switch (go.mode) {
      case 1:
        new Server().process();
        break;
      case 2:
        new Client().process();
        break;
      default:
        System.exit(0);
    }
  }
}
//This class defines a multi-threaded windows server for maintaining an
//phonebook of numbers to be add or found and deleed. A HashMap of Item objects is
//loaded from disk at start-up, maintained during processing, and written to
//disk at shut-down. 
class Server extends FrameWindow {
  //Instance variables for referencing a panel of components to display the
  //current inventory value and various status messages.
  private Panel statusPanel;
  //Private TextField valueField;
  private TextArea messages;
  //Instance variable for knowing if the file is currently open.
  private boolean openForInput;
  //Instance variable for referencing for the file path.
  private String filePath;
  //Instance variable for referencing the input file.
  private ObjectInputStream istream;
  //Instance variable for referencing the Map of inventory items.
  private Map items;
  //Class variable for referencing a Vector of thread references. Each client
  //that is currently connected will have a reference.
  private static Vector clients;
  //This constructor instantiates the server window.
  public Server() {
    //Call the superclass constructor to set the window's title.
    super("Server Side");
    //Set the frame's background color and size.
    setBackground(Color.lightGray);
    setSize(400, 140);
    //Center the frame on the screen and make it non-resizable.
    FrameWindow.center(this);
    setResizable(false);
    //Instantiate a panel to hold the current status messages.
    statusPanel = new Panel();
    statusPanel.setLayout(new FlowLayout());
    //Create a label and scrollable text area to display status messages and
    //add them to the panel. The text area may not be modified by the user.
    messages = new TextArea("", 5, 50, TextArea.SCROLLBARS_VERTICAL_ONLY);
    messages.setEditable(false);
    statusPanel.add(messages);
    //Add the status panel to the applet window.
    add(statusPanel);
    //Make the frame visible.
    setVisible(true);
  }
  //This method defines server processing.
  public void process() {
    //Instantiate a Vector to hold thread references for clients.
    clients = new Vector();
    //Local variable used to assign the next thread number.
    int threadNo = 1;
    //Display a start-up message.
    setMessage("Preparing to open the item file...");
    //Sleep for 3 seconds so the user can see the start-up message.
    try {
      Thread.sleep(3000);
    }
    catch (InterruptedException err) {}
    //Open the item file.
    openFile();
    //If the file is open, continue to activate server processing.
    if (openForInput) {
      //Start the automatic receiving thread and the thread to count the number
      //of records that have been created.
      startSupportThreads();
      //A "try" block to display the server address, declare a server socket for client
      //access, then loop to handle socket connections.
      try {
        //Display the server's internet address. The local host is used in this
        //application for testing purposes.
        setMessage("Server operational: " + InetAddress.getLocalHost());
        //Construct the server socket.  Port number 7000 is specified.
        ServerSocket mySocket = new ServerSocket(7000);
        //Loop to accept connections and start associated threads.
        while (true) {
          //Construct a socket when a client "hits" the server socket.
          Socket connection = mySocket.accept();
          //Construct a server thread to handle client transactions, add the
          //thread reference to the vector, and start the thread's processing.
          ServerThread next = buildThread(connection, threadNo);
          clients.add(next);
          next.start();
          //Increment the thread number.
          threadNo++;
        }
      }
      //Catch any errors and display the associated message.
      catch(IOException err) {
        setMessage(err.getMessage());
      }
    }
    //If the file isn't open, display an error message, delay for 3 seconds, and shut-down.
    else {
      setMessage("Server can't be activated");
      try {
        Thread.sleep(3000);
      }
      catch (InterruptedException err) {}
      dispose();
      System.exit(0);
    }
  }
  //This method can be called to open the item file. If the file specified by the user
  //is new (has a length of 0 bytes), it is automatically formatted to hold 3 Item objects.
  private void openFile() {
    //In a "try" bloack, open the file for input.
    try {
      //Create and display a FileDialog object through which the user may
      //specify the path (directory and file name) of the item file.
      FileDialog fd = new FileDialog(this, "Select item file", FileDialog.LOAD);
      fd.setVisible(true);
      //The file path is "pieced" together from information entered in the
      //FileDialog. The separator is platform dependent and obtained from the
      //File class.
      filePath = fd.getDirectory() + File.separator + fd.getFile();
      //If the specified file is empty, format it with 3 Item objects.
      if (new File(filePath).length() == 0) {
        //Object reference for an output stream.
        ObjectOutputStream ostream;
        //Instantiate a Map to hold the Item objects.
        items = new HashMap();
        //In a "try" block, open the file, populate the Map, and write the Map to disk.
        try {
          //Open the file by instantiating a new ObjectOutputStream object from
          //a new FileOutputStream object based upon the file path.
          ostream = new ObjectOutputStream(new FileOutputStream(filePath));
          //Write the Map to disk and close the file.
          ostream.writeObject(items);
          ostream.close();
        }
        //This catch block will display an appropriate error message.
        catch (Exception err) {
          setMessage(err.getMessage() + " while initializing inventory");
        }
      }
      //Open the file by instantiating a new ObjectInputStream object from a
      //new FileInputStream object.
      istream = new ObjectInputStream(new FileInputStream(filePath));
      //Indicate that file is open for output.
      openForInput = true;
      //Read the file as a generic object from disk and cast it to a Map.
      items = (HashMap) istream.readObject();
      //Display a message to indicate that the file is now open.
      setMessage("Item file is open with " + items.size() + " records");
    }
    //This catch is needed to satisfy the compiler. The exception may be
    //when reading the HashMap object from the disk file.
    catch(ClassNotFoundException err) {}
    //If an input error occurs, display an error message.
    catch(IOException x) {
      setMessage("Error reading item file");
    }
  }
  //This method can be called to instantiate and start the automatic receiving
  //thread and the thread to monitor the number of records that have been added.
  private void startSupportThreads() {
  }
  //This method can be called to instantiate and start a thread for processing
  //shipping requests from a client.
  private ServerThread buildThread(Socket connection, int threadNo) {
    //Construct the thread by passing it a reference to this frame, the socket,
    //the thread number, and the item Map. The reference is returned to the
    //caller.
    return new ServerThread(this, connection, threadNo, items);
  }
  //This method is automatically called when the window is being shut-down. It
  //overrides the windowClosing() method of the super class in order to kill
  //all threads and update the item file.
  public void windowClosing(WindowEvent e) {
    //Loop through the Vector of all client threads and kill them.
    for (int i = 0; i < clients.size(); i++) {
      ServerThread temp = (ServerThread) clients.get(i);
      temp.killThread();
    }
    //In a "try" block, write the updated Map back to the disk file;
    try {
      //Construct a new ObjectOutputStream for the item file.
      ObjectOutputStream ostream = new ObjectOutputStream(new FileOutputStream(filePath));
      //Write the Map to disk and close the file.
      ostream.writeObject(items);
      ostream.close();
      //Display a success message.
      setMessage("Item file is closed. " + items.size() + " records written");
    }
    //This catch block displays an appropriate error message.
    catch(IOException x) {
      setMessage("Error writing item file to disk");
    }
    //Sleep for 3 seconds so the user can see the closing messages.
    try {
      Thread.sleep(3000);
    }
    catch (InterruptedException err) {}
    //Release all resources used by the frame and terminate the JVM.
    dispose();
    System.exit(0);
  }
  //This method can be called to add a new message to the scrollable text area.
  //It uses synchronization so that only one thread at a time can call the method.
  public synchronized void setMessage(String newMessage) {
    messages.append(newMessage + "\n");
  }
}
//This class defines the processing of a server thread associated with a single client.
class ServerThread extends Thread {
  //Instance variable for knowing the current thread state.
  Map myObjects;
  private boolean alive;
  //Instance variables for referencing the parent server and the Map of
  //inventory items.
  private Server theServer;
  private Map theItems;
  //Instance variables for holding the thread number and the transaction code.
  private int threadNumber;
  private int transCode;
  //Instance variables for referencing the socket connection, a reader for
  //reading a transaction from the client, and a writer for sending a reply to
  //the client.
  Socket connection;
  ObjectInputStream fromClient;
  ObjectOutputStream toClient;
  //Instance variable to reference a StringTokenizer to be used in parsing
  //data received from the client.
  StringTokenizer dataAsString;
  //Public constants for transaction codes and resulting status codes.
  public static final int ADD = 1;
  public static final int DELETE = 2;
  public static final int FIND = 3;
  public static final boolean ACCEPTED = true;
  public static final boolean REJECTED = false;
  //This constructor instantiates the thread. It receives as parameters a
  //reference to the parent server, a reference to the socket, the assigned
  //thread number, and a reference to the Map of objects.
  public ServerThread(Server iTheServer, Socket mySocket, int myThreadNumber,
                      Map imyObjects) {
    //Indicate that the thread is now alive.
    alive = true;
    //Save the parent reference, socket reference, thread number, and objects
    //Map reference.
    theServer = iTheServer;
    connection = mySocket;
    threadNumber = myThreadNumber;
    theItems = imyObjects;
    //Display a message indicating that the thread is running.
    theServer.setMessage("Thread " + threadNumber + ": running");
    //In a "try" block, create objects for reading and writing data streams.
    //The PrintWriter will automatically flush the stream after data is sent.
    try {
      fromClient = new ObjectInputStream(connection.getInputStream());
      toClient = new ObjectOutputStream(connection.getOutputStream());
    }
    //If an error occurs, display the message associated with the error.
    catch (IOException err) {
      theServer.setMessage(err.getMessage());
    }
  }
  //This method defines thread processing.
  public void run() {
    //Loop while the thread is alive.
    while (alive == true) {
        switch (transCode) {
          //This case enters all the item's data into the file, item name, item
          //number, and item price.
          case ADD: {
try {       
  Person tem = (Person)fromClient.readObject();
tem.getPhoneNumber ();
tem.getPhoneNumber ();
          
theItems.put(tem.getItemName(),tem);
toClient.writeBoolean(true);
}
catch(Exception err) {}
  //Local variable for referencing the current item.
            //Person current;
            //Break out of the switch.
            break;
          }
          //This case handles a request to delete item information from the file.
          case DELETE: {
            //Local variable for referencing the current item.
            Person current;
           
    }
    //This case will find the items in the record.
    case FIND:{
    }
    
  }
}
}
  //Calling this method will set the thread state to indicate the thread is no longer alive.
  public void killThread() {
    alive = false;
  }
}
//This class defines a frame with exit handling features so it can be properly closed.
//It subclasses Frame and implements a WindowListener interface in order to respond to
//window events. A static (class) method is also provided to permit any window to be
//centered on the screen.
class FrameWindow extends Frame implements WindowListener {
  //This constructor accepts no parameters. It calls the superclass constructor
  //and registers a listener to be notified of window events.
  public FrameWindow() {
    super();
    addWindowListener(this);
  }
  //This constructor accepts a String for the frame's title and passes it through to
  //the superclass constructor. It then registers a listener to be notified of window events.
  public FrameWindow(String title) {
    super(title);
    addWindowListener(this);
  }
  //This class method can be called to center any window on the screen. The window
  //is received as a parameter. If it is too large to fit, it is downsized.
  public static void center(Window theWindow) {
    //Determine the screen size, its width and height, in pixels.
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    int screenWidth = screenSize.width;
    int screenHeight = screenSize.height;
    //Determine the window size.
    Dimension frameSize = theWindow.getSize();
    //Calculate the x and y coordinates for top left corner of the window.
    int x = (screenWidth - frameSize.width) / 2;
    int y = (screenHeight - frameSize.height) / 2;
    //If the window is bigger than the screen, size the it to fit.
    if (x < 0) {
      x = 0;
      frameSize.width = screenWidth;
    }
    if (y < 0) {
      y = 0;
      frameSize.height = screenHeight;
    }
    //Move the window to its new location.
    theWindow.setLocation(x, y);
  }
  //Implement the abstract windowClosing() method of the WindowListener interface.
  public void windowClosing(WindowEvent e) {
    //Release all resources used by the frame and terminate the JVM.
    dispose();
    System.exit(0);
  }
  //Implement other abstract methods of the WindowListener interface.
  public void windowOpened(WindowEvent e) {}
  public void windowActivated(WindowEvent e) {}
  public void windowIconified(WindowEvent e) {}
  public void windowDeiconified(WindowEvent e) {}
  public void windowDeactivated(WindowEvent e) {}
  public void windowClosed(WindowEvent e) {}
}
//This class encapsulates the data and processing of an inventory item. It
//uses synchronization to lock the object and prevent simultaneous processing
//by multiple threads. The Serializable interface is implemented to permit
//object data to be read or written.
class Person implements Serializable {
  //Instance variables for item number, item name, and item price.
//itemNumber
  private String phoneNumber;
  private String itemName;
  //This constructor instantiates an item using values received as parameters.
  //It may throw an Exception if the data is invalid.
  public Person(String iPhoneNumber, String iItemName) throws Exception {
    //Try to pass each value to its corresponding set method.
    try {
      setPhoneNumber(iPhoneNumber);
      setItemName(iItemName);
     
    }
    //This catch block will be executed if any of the set methods threw an
    //Exception due to invalid data. It re-throws the error message.
    catch (Exception err) {
      throw new Exception(err.getMessage());
    }
  }
  //This method sets a new value for the phone number. The item number must be positive.
  //If it isn't, an Exception is thrown. Due to synchronization, only one thread at a
  //time can call the method.
  public synchronized void setPhoneNumber(String newNumber) throws Exception {
   if (newNumber.length() == 0) {
      throw new Exception("Invalid phone number");
    }
    else {
      phoneNumber = newNumber;
    }
  }
  //This method sets a new value for the item name. It can not be blank or null.
  //If it is, an Exception is thrown. Due to synchronization, only one thread at a time
  //can call the method.
  public synchronized void setItemName(String newItemName)
    throws Exception {
    if (newItemName == null || newItemName.length() == 0) {
      throw new Exception("Invalid description");
    }
    else {
      itemName = newItemName;
    }
  }
 
  //This method can be called to get the item number. Synchronization is used so
  //that only one thread at a time can call the method.
  public synchronized String getPhoneNumber() {
    return phoneNumber;
  }
  //This method can be called to get the item name. Synchronization is used so that
  //only one thread at a time can call the method.
  public synchronized String getItemName() {
    return itemName;
  }

}
//This class defines a windows client.  It connects to and communicates with
//a multi-threaded server that assigns it a unique thread to process its
//transactions.
class Client extends FrameWindow implements ActionListener, ItemListener {
  //Object references for networking.
  Socket connection;
  ObjectInputStream fromServer;
  ObjectOutputStream toServer;
  //Object reference for the current object.
  Person current;
  int transCode = 0;
  //Object references for the buttons in which the user presses in order to add, find,
  //delete or update item information, user interface components.
  Button add;
  Button find;
  Button delete;

  //Object references for the labels that label the textfields.
  Label itemname;
  Label phonenumber;
  //Object references for the textfields in which there is user input and also where
  //the results of a find will be displayed too.
  TextField phoneNumber;
  TextField itemName;
  TextArea message;

  //This constructor initializes the window.
 public Client() {
          // Call the superclass constructor and pass it the window title.
          super("Phonebook Client");
          // Specify the size (non-resizable), background color, and layout manager
          // for the frame.
          setSize(350, 350);
          setResizable(false);
          setBackground(Color.lightGray);
          setLayout(new FlowLayout());
          // Display a labeled list of item names from which the user may select the
          // item to be shipped. The list is initially empty. The item names will be
          // loaded from the server after the connection is established.
          
          // Display a labeled text box in which the user may enter how many of the
          // selected item are to be removed from the inventory.
            itemname = new Label("Enter Name");
           itemname.setAlignment(Label.CENTER);
            itemname.setFont(new Font("Serif", Font.BOLD, 16));
add(itemname);
 
          itemName = new TextField("           ");
          add(itemName);
          
          // Display a labeled text box in which the user may enter information about
          // where or to whom the shipment is to be sent.
 phonenumber = new Label("Enter  Phone Number");
    phonenumber.setAlignment(Label.CENTER);
    phonenumber.setFont(new Font("Serif", Font.BOLD, 16));
  add(phonenumber);
        phoneNumber = new TextField("           ");
        add(phoneNumber);
add = new Button("Add");
add.addActionListener(this);
add(add);
    
    find = new Button("Find");
    find.addActionListener(this);
    add(find);

    delete = new Button("Delete");
delete.addActionListener(this);
    add(delete);

        
// Construct a non-editable area in which messages may be displayed.
    message = new TextArea("",5,20,TextArea.SCROLLBARS_HORIZONTAL_ONLY);
    message.setFont(new Font("Serif", Font.ITALIC, 16));
    message.setEditable(false);
    add(message);
          
// Make the frame visible.
          setVisible(true);
        }

  //This method defines client processing.
  public void process() {
    //A "try" block, to connect to the server.
    try {
      //Connect to port 7000 on the current machine.
      connection = new Socket("localhost", 7000);
      message.setText("Connected to server");
      //Create objects for reading and writing data streams. The PrintWriter will
      //automatically flush the stream after data is sent.
      fromServer = new ObjectInputStream(connection.getInputStream());
      toServer = new ObjectOutputStream(connection.getOutputStream());
    }
    //If an error occurs, display a message.
    catch (IOException err) {
      message.setText("Connection error");
    }
  }
  //This method implements the abstract method of the ActionListener interface.  In
  //this client, it will be called only when the user has clicks the add button.
  public void actionPerformed(ActionEvent e) {
  if (e.getSource().equals(add)) {
      try{
      if ((itemName.getText().trim().equals("")) | (phoneNumber.getText().trim().equals("")))
        {
          message.setText("Must enter all fields");
        }
     else {

         
itemName.setText("");
        phoneNumber.setText("");
        message.setText("Number Saved");    
System.out.println("saved");
        transCode = 1;
 
//inset trans code
Person tem = new Person (itemName.getText(),phoneNumber.getText());
toServer.writeInt(1);
toServer.writeObject(tem);
boolean reply = fromServer.readBoolean();

      if (reply == true);
//else {}

          }
          }
     catch(Exception err){
      message.setText(err.getMessage());
    }
    //If the socket is connected, continue to construct the transaction.
    if (connection != null) {
        }
      }
    }
  //This method implements the abstract method of the ActionListener interface.
  public void itemStateChanged(ItemEvent e) {
  //Display a prompt message and give the "quantity to ship" field focus.
  message.setText("Enter quantity and \"ship to\"");
}
}
//This class defines a frame for a modal, two-option dialog box that may be
//launched by another window. It subclasses Dialog and implements the
//WindowListener interface to handle window events. Anonymous inner interfaces
//are used to handle action events.
class OptionDialog extends Dialog implements WindowListener {
  //Instance variable for holding the user's selection.
  private int selection;
  //This constructor constructs the modal message dialog box. As parameters, it
  //receives a reference to the parent frame, a String for the title, and two
  //String objects for the options to be displayed.
  public OptionDialog(Frame owner, String title, String opt1, String opt2) {
    //Pass the parent frame reference, title, and modal specifier through to the
    //superclass (Dialog) constructor.
    super(owner, title, true);
    //Set the layout manager for the dialog box.
    setLayout(new GridLayout(1,2));
    //Construct a Button for each option to be displayed, add them to the dialog box
    //window, and define their processing via an anonymous inner ActionListener.
    Button b1 = new Button(opt1);
    b1.setFont(new Font("Serif", Font.BOLD, 18));
    add(b1);
    b1.addActionListener(
      new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          //Save selection and release dialog box resources.
          selection = 1;
          dispose();
        }
      }
    );
    Button b2 = new Button(opt2);
    b2.setFont(new Font("Serif", Font.BOLD, 18));
    add(b2);
    b2.addActionListener(
      new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          //Save selection and release dialog box resources.
          selection = 2;
          dispose();
        }
      }
    );
    //Set the size of the dialog box window, center it on the screen, register its
    //listener, and make it visible.
    setSize(250, 100);
    FrameWindow.center(this);
    addWindowListener(this);
    show();
  }
  //This method can be called to obtain the selection.
  public int choice() {
    return selection;
  }
  //Implement the abstract windowClosing() method of the WindowListener interface.
  public void windowClosing(WindowEvent e) {
    //Release dialog box resources.
    dispose();
  }
  //Implement other abstract methods of the WindowListener interface.
  public void windowOpened(WindowEvent e) {}
  public void windowActivated(WindowEvent e) {}
  public void windowIconified(WindowEvent e) {}
  public void windowDeiconified(WindowEvent e) {}
  public void windowDeactivated(WindowEvent e) {}
  public void windowClosed(WindowEvent e) {}
}
//This class defines the transcode which is serializable.
class Transcode implements Serializable {
//Instance variables for the transcode number, the itme object, and the status of
//the object which is a boolean.
private int transcode;
Person object;
private boolean status;
//This constructor instantiates the transcode. It receives as parameters a reference
//to the transcode, a reference to the object, and the status of the transcode.
public Transcode ( int itranscode, Person iobject, boolean istatus)throws Exception {
//A "try" block to set the transcode, object, and status.
  try {
      setTranscode(itranscode);
      setObject(iobject);
      setStatus(istatus);
    }
//If an error occurs, display the message associated with the error.
catch (Exception err) {
      throw new Exception(err.getMessage());
    }
  }
//This method can be called to set the transcode. Synchronization is used so that
//only one thread at a time can call the method.
public synchronized void setTranscode(int newTranscode) throws Exception {
    if (newTranscode <= 0) {
      //If an error occurs, display the message associated with the error.
      throw new Exception("Invalid trans code");
    }
    else {
      transcode = newTranscode;
    }
  }
  //This method can be called to set the item object. Synchronization is used so that
  //only one thread at a time can call the method.
  public synchronized void setObject(Person newObject) throws Exception {
    if (newObject.equals("")) {
      //If an error occurs, display the message associated with the error.
      throw new Exception("Invalid Object");
    }
    else {
      object  = newObject;
    }
  }
   //This method can be called to set the status of the transcode. Synchronization is
   //used so that only one thread at a time can call the method.
   public synchronized void setStatus(boolean newStatus) throws Exception {
    if (newStatus == false) {
      //If an error occurs, display the message associated with the error.
      throw new Exception("Invalid Status");
    }
    else {
      status  = true;
    }
  }
    //This method can be called to get the transcode. Synchronization is used
    //so that only one thread at a time can call the method.
    public synchronized int gettranscode() {
    return transcode;
  }
  //This method can be called to get the item object. Synchronization is used so
  //that only one thread at a time can call the method.
  public synchronized Person getobject() {
    return object;
  }
  //This method can be called to get the status. Synchronization is used so that
  //only one thread at a time can call the method.
  public synchronized boolean getstatus() {
    return status;
  }
}

[Joe Ess]

It would probably make things easier for both of use if you'd start from scratch. Write a client and a server that just send a string back and forth. Then add a feature, like sending a Person object, and get that to work. It would be far simpler to narrow down what isn't working in that case than plowing through this 1000 lines of code, not to mention you'd have a better grasp as to what's going on in your code.
It would pay to become familiar with the API Documentation. For example, you may have noticed that in the entry for java.io.ObjectInputStream it says:

The ObjectInputStream constructor blocks until it completes reading the serialization stream header. Code which waits for an ObjectInputStream to be constructed before creating the corresponding ObjectOutputStream for that stream will deadlock. . .

In other words, your server thread never starts up because execution is blocked on fromClient = new ObjectInputStream(connection.getInputStream());
One useful debug technique is putting System.out.println(""); statements everywhere and watch the console to make sure you have the values you think you do. You may have noticed that around line 820 you do this:

itemName.setText("");
phoneNumber.setText("");

then a few lines later you do this:

Person tem = new Person (itemName.getText(),phoneNumber.getText());

phoneNumber is blank. That's why you are getting that invalid number message.
[ December 02, 2003: Message edited by: Joe Ess ]