Integer cannot be cast to client

[Wes Traylor]

Looking for some help on a Client Server program for class. I am stuck on an error that says "java.lang.Integer cannot be cast to client1.Client$Employee". Not for sure what this is and have spent several hours working on it and trying different things. Anyone have any ideas?

Server Code:

  /*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package server1;

/**
 *
 * @author Computer1
 */
// Import statements make it possible to reference required packaged code.

import java.io.*;
import java.net.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

// This class defines a server that allows connection of multiple clients
// to access a shared file of employee data.
// ---- Written by: Jon Huhtala
// ---- Modified by: Wesley P Traylor


// This class encapsulates the data and processing of an employee.
// ---- Written by: Jon Huhtala

public class Server {

    // Variables

  String path = "c:/temp/employees.txt";      // Path of disk file
  Map employees = new TreeMap();              // The employee collection
  Employee emp;                               // The current Employee object
  int port = 7000;                            // Port number
  int loginNumber = 0;                        // For counting logins
  ArrayList threads;                          // For storing thread references
  JPanel panel;                               // Component panel
  TextArea message;                           // For Scrolling message area
  JFrame frame;                               // Reference for main window
  JButton exit;                               // EXIT button

  // Main method to create a Server object and begin its processing.

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    new Server().go();
  }

  // This method builds the server GUI, reads data from disk and loads
  // it into the collection, establish a port, and receive client logins.

  public void go() {

    // Build the GUI.

    frame = new JFrame("Server");
    frame.setSize(350, 275);
    frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
    panel = new JPanel();
    panel.setLayout(new FlowLayout());
    panel.add(new JLabel("Server Status and Messages"));
    message = new TextArea("", 10, 40, TextArea.SCROLLBARS_VERTICAL_ONLY);
    message.setBackground(Color.black);
    message.setForeground(Color.yellow);
    panel.add(message);
    exit = new JButton("EXIT");
    exit.addActionListener(new ExitListener());
    panel.add(exit);
    frame.getContentPane().add(panel);
    frame.setVisible(true);

    // Read data from disk and load the collection.
    //String path = "c:/temp/employees.txt";
    //boolean done = false;
    try {
      FileReader fr = new FileReader(path);
      BufferedReader br = new BufferedReader(fr);
      String line = br.readLine();
      while (line != null) {
        StringTokenizer parser = new StringTokenizer(line, ",");
        ArrayList fields = new ArrayList();
        while (parser.hasMoreTokens()) {
          fields.add(parser.nextToken());
        }
        System.out.println(fields.get(0) + ", " + fields.get(1));
        line = br.readLine();
      }
      br.close();
    }
      catch (IOException err) {
      System.out.println(err.getMessage());
    }
    message.append("Collection loaded" + "\n");
    

    // Establish a port and accept client logins.

    try {
      ServerSocket ss = new ServerSocket(port);
      message.append("Server active" + "\n");
      message.append("Address: " + InetAddress.getLocalHost() + "\n");
      message.append("Port: " + port + "\n");
      threads = new ArrayList();
      while (true) {
        Socket s = ss.accept();

        // Create a thread to process requests from the client, add it
        // to the list of threads, and start its processing.

        ServerThread thread = new ServerThread(s, loginNumber);
        threads.add(thread);
        thread.start();
        loginNumber++;
      }
    }
    catch(IOException err) {
      message.append(err.getMessage() + "\n");
    }
  }

  // This inner class defines an action listener for the exit button.

  class ExitListener implements ActionListener {

    // When the button is clicked, all active threads are killed, data
    // is written back to disk from the collection in ascending employee
    // number order, and the server is shutdown.

    public void actionPerformed(ActionEvent e) {
      for (int i = 0; i < threads.size(); i++) {
        ((ServerThread)threads.get(i)).kill();
        threads.remove(i);
      }
      Iterator p = employees.keySet().iterator();
      try {
          // YOUR CODE TO WRITE THE COLLECTION'S DATA BACK TO DISK IN
      // ASCENDING KEY SEQUENCE GOES HERE
      FileOutputStream fs = new FileOutputStream(path);
      ObjectOutputStream os = new ObjectOutputStream(fs);
      System.out.println("Objects written to: " + path);
      os.close();
      System.out.println("File is closed");
      }
      catch (IOException err) {
        message.append(err.getMessage() + "\n");
      }
      frame.dispose();
      System.exit(0);
    }
  }

  // This inner class encapsulates the thread processing for a single client.

  class ServerThread extends Thread {

    // Variables

    boolean alive;                  // For continuing thread processing
    int threadNum;                  // For holding assigned thread number
    Socket s;                       // Reference for the thread's Socket
    ObjectOutputStream toClient;    // For writing objects to the client
    ObjectInputStream fromClient;   // For reading objects from the client

    // This constructor initializes the ServerThread object, creates
    // object streams for communicating with the client, and sends the
    // client its Integer thread number.

    public ServerThread(Socket mySocket, int myThreadNum) {
      s = mySocket;
      threadNum = myThreadNum;
      try {
        toClient = new ObjectOutputStream(s.getOutputStream());
        fromClient = new ObjectInputStream(s.getInputStream());
        toClient.writeObject(new Integer(threadNum));
        toClient.flush();
        message.append("Thread " + threadNum + ": Connected" + "\n");
      }
      catch(IOException err) {
        message.append("Thread " + threadNum + ": " + err.getMessage() + "\n");
      }
    }

    // This method defines thread processing with the client. The thread is
    // marked as being alive, then it loops to handle client requests until
    // it is killed.

    public void run() {
      alive = true;
      while (alive) {
        try {
          String request = (String)fromClient.readObject();

          // Processing for a "FIND" request.

          if (request.equals("FIND")) {

            // Read the employee number from the client. If it matches that
            // of an existing employee, get the Employee object from the
            // collection and send it to the client. Otherwise, send a "dummy"
            // Employee object to indicate that the requested employee was
            // not found.

            Integer empNum = (Integer)fromClient.readObject();
            if (employees.containsKey(empNum)) {
              emp = (Employee)employees.get(empNum);
              toClient.writeObject(emp);
              toClient.flush();
              message.append("Thread " + threadNum + ": FOUND employee " +
                             emp.getNumber() + "\n");
            }
            else {
              toClient.writeObject(new Employee(0, ""));
              toClient.flush();
              message.append("Thread " + threadNum +
                             ": DID NOT FIND employee " +
                             empNum.intValue() + "\n");
            }
          }

          // Processing for an "ADD" request.

          else if (request.equals("ADD")) {

            // Read the Employee object from the client. If an employee
            // with a matching employee number already exists, send an error
            // String to the client. Otherwise, put the Employee object into the
            // collection and send a verification String to the client.

            emp = (Employee)fromClient.readObject();
            if (safeUpdate() == false) {
              toClient.writeObject("NOT ADDED");
              toClient.flush();
              message.append("Thread " + threadNum +
                             ": DID NOT ADD employee " +
                             emp.getNumber() + "\n");
            }
            else {
              toClient.writeObject("ADDED");
              toClient.flush();
              message.append("Thread " + threadNum + ": ADDED employee " +
                             emp.getNumber() + "\n");
            }
          }

          // Processing for a "DISCONNECT" request.

          else if (request.equals("DISCONNECT")) {
            alive = false;
            message.append("Thread " + threadNum + ": DISCONNECTING" + "\n");
          }

          // Processing for an invalid request. The thread is killed due to
          // the difficulty of re-synchronizing client communications.

          else {
            alive = false;
            message.append("Thread " + threadNum +
                           ": INVALID: " + request + "\n");
          }
        }
        catch (Exception err) {
          alive = false;
          message.append("Thread " + threadNum + ": " +
                         err.getMessage() + "\n");
        }
      }

      // Close the object streams as thread processing ends.

      try {
        fromClient.close();
        toClient.close();
        message.append("Thread " + threadNum + ": DISCONNECTED" + "\n");
      }
      catch (Exception err) {
        message.append("Thread " + threadNum + ": " + err.getMessage() + "\n");
      }
    }

    // This method can be called to kill the thread's processing loop.

    public void kill() {
      alive = false;
    }

    // This method can be called to safely update the collection in a
    // multithreaded environment.

    public synchronized boolean safeUpdate() {    // CHANGE WHERE SHOWN
      if (employees.containsKey(new Integer(emp.getNumber()))) {
        return false;
      }
      else {
        employees.put(new Integer(emp.getNumber()), emp);
        return true;
      }
    }
  }
}
class Employee implements Serializable {    // CHANGE WHERE SHOWN

  // Instance variables

  private int number;
  private String name;

  // This constructor will initialize employee data to values supplied by
  // the caller. No editing is performed (let's hope they get it right).

  public Employee(int iNumber, String iName) {
    number = iNumber;
    name = iName;
  }

  // These "getter" methods will return the corresponding employee data.

  public int getNumber() {
    return number;
  }
  public String getName() {
    return name;
  }
}
  

Client Code:

  /*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package client1;

import java.io.*;
import java.net.*;
import java.awt.event.*;
import java.awt.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.*;
import javax.swing.border.*;

public class Client {

    // Variables

    JPanel p1;
    JPanel p2;
    JFrame frame;                               // Reference for main window
    JButton exit;
    JButton find;
    JButton add;
    JButton disconnect;
    JLabel message1;
    JLabel message2;
    JTextField empNum;
    JTextField empName;
    ObjectInputStream fromServer;
    ObjectOutputStream toServer;
    Employee emp;
    //Integer n;
    //boolean disconnect;
    int threadNum;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    new Client().go();
    }
   //private DataInputStream fromServer;
    //private DataOutputStream toServer;

    public void go() {
      // Build the GUI panel 1

      p1 = new JPanel();
      p1.setLayout(new GridLayout(2, 2,5,5));
      p1.add(message1 = new JLabel("Employee Number"));
      p1.add(empNum = new JTextField(""));
      p1.add(message2 = new JLabel("Employee Name"));
      p1.add(empName = new JTextField(""));
      p1.setBorder(new TitledBorder(new LineBorder (Color.BLUE, 2),"Employee Data"));
      
      // Build the GUI panel 2

      p2 = new JPanel();
      p2.setLayout(new GridLayout(2, 2,5,5));
      p2.add(find = new JButton("Find"));
      find.addActionListener(new FindListener());
      p2.add(add = new JButton("Add"));
      add.addActionListener(new AddListener());
      p2.add(disconnect = new JButton("Disconnect"));
      disconnect.addActionListener(new DisconnectListener());
      p2.add(exit = new JButton("EXIT"));
      exit.addActionListener(new ExitListener());
      p2.setBorder(new TitledBorder(new LineBorder (Color.BLUE, 2),"Server Functions"));

      // Add contents into the frame

      frame = new JFrame("Client");
      frame.setSize(300, 200);
      frame.setLocationRelativeTo(null);
      frame.setLayout(new GridLayout(2,1,5,5));
      frame.add(p1);
      frame.add(p2);
      frame.setResizable(false);
      frame.setVisible(true);
    
      try {

        //Socket s = new Socket("localhost", 7000);
        //ObjectInputStream fromServer = new ObjectInputStream(s.getInputStream());
        //ObjectOutputStream toServer = new ObjectOutputStream(s.getOutputStream());
      
      Socket socket = new Socket("localhost", 7000);
      fromServer = new ObjectInputStream(socket.getInputStream());
      toServer = new ObjectOutputStream(socket.getOutputStream());
      //System.out.println("Connected to server");

      
    }
    catch(Exception err) {
      System.out.println(err.getMessage());
    }
  }
    public class ExitListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
        frame.dispose();
        System.exit(0);
}
}
 public class FindListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {

            try {
                Integer n = (Integer.parseInt(empNum.getText()));
                toServer.writeObject((String)"FIND");
                toServer.writeObject(n);
                toServer.flush();
                emp = (Employee)fromServer.readObject();
                System.out.println("emp name: " + emp.getName());
                System.out.println("emp number: " + emp.getNumber());
            } catch(Exception err) {
                System.out.println(err.getMessage());
            }
}
 }
 public class AddListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            //disconnect = true;
            try {
                toServer.writeObject((String)"ADD");
                toServer.writeObject(new Employee(Integer.parseInt(empNum.getText()),empName.getText()));
                toServer.flush();
                empName.setText((String)fromServer.readObject());
                }
                catch(Exception err) {
                System.out.println(err.getMessage());
                }
            }
 }
 
 public class DisconnectListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            try {
                toServer.writeObject((String)"DISCONNECT");
                }
                catch(Exception err) {
                System.out.println(err.getMessage());
                }
            }

 
}
class Employee implements Serializable {

// Instance variables

private int number;
private String name;

// This constructor will initialize employee data to values supplied by
// the caller. No editing is performed (let's hope they get it right).

public Employee(int iNumber, String iName) {
number = iNumber;
name = iName;
}

// These "getter" methods will return the corresponding employee data.

public int getNumber() {
return number;
}
public String getName() {
return name;
}
}
}


  

[Ernest Friedman-Hill]

Hi Wes,

That's a lot of code; it would sure help if you'd give us all the information the compiler is giving you -- i.e., the line number where the error occurs!

But in general terms, it looks like you're using serialization to send objects between a client and server process over a socket. I see Strings, Integers, and Employee objects being written, and I see places in the code where you're reading an object and expecting it to be an Integer, a String, or an Employee, at different points. In any case, the error just means -- and I think you probably know this -- that at one of the points where you're expecting an Integer, the object you're getting over the socket is actually an Employee. All I can tell you is that you need to go over the logic, carefully, and make sure you understand the conditions under which each kind of object can be transmitted; and make sure that the other end always has a way to know what's coming next.

[Wes Traylor]

I get this error from the code when I try to use the FindListener:

java.lang.Integer cannot be cast to client1.Client$Employee

On the client side this is the part of the code I'm having trouble with.

Sorry for the long code, wanted to include everything so that someone could copy and paste to run.

   public class FindListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {

            try {
                Integer n = (Integer.parseInt(empNum.getText()));
                toServer.writeObject((String)"FIND");
                toServer.writeObject(n);
                toServer.flush();
                emp = (Employee)fromServer.readObject();
                System.out.println("emp name: " + emp.getName());
                System.out.println("emp number: " + emp.getNumber());
            } catch(Exception err) {
                System.out.println(err.getMessage());
            }
} 

[Ernest Friedman-Hill]

The server logs some messages for every request it processes. When you run this, and have an error with the FIND command, do you see FIND-related messaages on the server? What do they say?

[Steve Luke]

The problem is that when your Server first connects to a client, it sends an Integer as a handshake, and your Client never reads that Integer. So later, when you do a FIND, then read the input stream you get the Integer that has been sitting there in the buffer waiting to be taken.

you should read the integer immediately after making the connection to the Server:

public class Client ...
{
    ...
    public void go()
    {
        ...
        try {
            Socket socket = new Socket("localhost", 7000);
            fromServer = new ObjectInputStream(socket.getInputStream());
            toServer = new ObjectOutputStream(socket.getOutputStream());

            //Read in the Integer handshake from the server
        }
            catch(Exception err) {
            System.out.println(err.getMessage());
        }