百思不得其解？？

Question

我正在写一个客户端和服务器通讯的多线程小程序，步骤很接单，服务器先运行，之后每个客户端打开的时候都可以享用一个独立线程，然后客户端向服务器发出货物请求:writeObject(order),服务器端接受readObject(order)之后处理，然后给客户端回复。现在我遇到一个问题，程序运行没有问题，当一个客户端给服务器发出第一个请求的时候，结果OK!
客户端：writeObject(order1),服务器：readObject(order1)。
但是当这个客户端修改了货物请求
客户端：writeObject(order2),问题出来了：服务器死活是：readObect(order1)。怎么也不变化。我调试了一下，从客户端writeObject(order2)之前的数据都是对的。连接也没有问题（第一次能成功），就是从服务器端出来的是第一次的order1，不管重复改变多少次，就是不行。
stream我也flush()了，实在找不出问题所在。打个比方：我第一次从一个管道这头送进一头牛，从管道那头就出了一头牛。
          之后我不管送什么其它别的动物进去，那头就是出牛！！因为学习JAVA不久，所以请遇到过这种问题的哥们帮忙解决一下，给点提示。谢谢！

Answer 1

部分代码：
服务器端：
public class A3Server
    extends JFrame
    implements ActionListener {  /** Constructor */
  public A3Server() {
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);
    try {
      init();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }  /** Initialize the constructor */
  private void init() {
  ...
  ...
  try {
      // Create a server socket
      ServerSocket serverSocekt = new ServerSocket(8000);
      // For accept multithreads
      while (true) {
        jlClientNum.setText("There are " + clientNum +
                            " clients connecting to the server");
        // Listen for a new connection request
        Socket socket = serverSocekt.accept();
        inetAddress = socket.getInetAddress();
        jtaInfo.append("\n" + "Client \"" + inetAddress.getHostName() +
                       "\" established the connection.");
        // Create a new thread for the connection
        HandleAClient thread = new HandleAClient(socket);
        thread.start();
        clientNum++;
      }
    }
    catch (IOException e) {
      jtaInfo.append("\n" + e.toString());
    }
  }
  /** Define the thread class for handling new connection */
  class HandleAClient
      extends Thread {
    private Socket socket;
    public HandleAClient(Socket socket) {
      this.socket = socket;
    }
    /** Run a thread */
    public void run() {
      try {
        // Create data input and output streams
        ObjectOutputStream outputToClient = new ObjectOutputStream(
            socket.getOutputStream());
        ObjectInputStream inputFromClient = new ObjectInputStream(
            socket.getInputStream());        // Send the initial inventory to the client
        outputToClient.writeObject(vInventory);
        outputToClient.flush();        // Continuously serve the client
        while (true) {
          // Receive one order from the client
          Order oneOrder;          //Order oneOrder = (Order) inputFromClient.readObject();
          Object o = (Object) inputFromClient.readObject();          if (o instanceof String) {
            oneOrder = null;
          }
          else {
            oneOrder = (Order) o;
            // Check order
            if (checkOrder(oneOrder) == false) {
            ...
            ...
            // Give feedback
            }
            else{
            // Return error message
            }
          }
        }
      }
      catch (ClassNotFoundException ex) {
        jtaInfo.append(ex.toString());
      }
      catch (IOException e) {
        clientNum--;
        jlClientNum.setText("There are " + clientNum +
                            " clients connecting to the server");
        jtaInfo.append("\n" + "One Client has quited!");
      }
    }
  }
}
客户端：
public class A3Client
    extends JApplet
    implements ActionListener {
  ...
  ...
  ...
  /**Initialize the applet*/
  public void init() {
    try {
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }  /** Component initialization*/
  private void jbInit() throws Exception {
    // Create a socket to connect to the server
    Socket socket;
    if (isStandalone) {
      socket = new Socket("localhost", 8000);
    }
    else {
      socket = new Socket(getCodeBase().getHost(), 8000);
    }
    // Create a input stream to receive the data from server
    inputFromServer = new ObjectInputStream(socket.getInputStream());
    outputToServer = new ObjectOutputStream(socket.getOutputStream());
    ...
    ...
    ...
    // Open a thread for read and write
    this.nl = new NetListener(inputFromServer);
    this.nl.start();
  }  /** Components action events*/
  public void actionPerformed(ActionEvent e) {
    if (e.getSource() == jbAdd) {
    ...
    ...
    else if (e.getSource() == jbConfirm) {
      Client oneClient = new Client(jtfName.getText().trim(),
                                    jtfAddress.getText().trim());
      Order oneOrder = new Order(oneClient, vCart);
      try {
        if(vCart.size() > 0){
          outputToServer.writeObject(oneOrder);
          outputToServer.flush();
        }
      }
      catch (IOException ex) {
        jtaInfo.append(ex.toString());
      }
    }
  }  /** Run the applet as an application */
  public static void main(String[] args) {
  ...
  ...
  ...
  }
  ...
  ...
  ...
  /** Inner class receive vector from server and bind to the list */
  class NetListener
      extends Thread {
    ObjectInputStream ois;    public NetListener(ObjectInputStream ois) {
      this.ois = ois;
    }    public void run() {
      while (true) {
        try {
          Object o = (Object) inputFromServer.readObject();
          // If receive the message
          if (o instanceof String) {
            jtaInfo.append("\n" + o.toString());
          }
          // Get the changed Inventory
          else {
          ...
          ...
          ... 
          }
        }
        catch (Exception ex) {
          System.out.println(ex);
        }
      }
    }
  }
}
请大家帮忙看看！！谢谢！！

Answer 2

不好意思,没看出什么问题.写了个简单的测试,不妨用来对照一下,如果发现问题,请贴出.大家学习一下.
 class Server { 
   ServerSocket serverSocket;;
   public static void main(String[] args) {
     int port = 8000;
     new Server(port);
     new Client(port);
   }
   
   public Server(int port) {
     try {
       serverSocket = new ServerSocket(port);
       new Thread(){
         public void run(){
           try {
             while (true) {
               System.out.println("\t\t\tServer is waiting");
               Socket socket = serverSocket.accept();
               System.out.println("\t\t\tServer gets one connection");
               new ClientHandler(socket).start();
             }
           }
           catch (Exception e) {
             e.printStackTrace();
           }
         }}.start();
     }
      catch (Exception e) {
        e.printStackTrace();
      }
   }
 
   class ClientHandler extends Thread {
     ObjectInputStream i;
     ObjectOutputStream o;
     public ClientHandler(Socket socket) throws Exception {
       o = new ObjectOutputStream(socket.getOutputStream());
       i = new ObjectInputStream(socket.getInputStream());
     }
 
     public void run() {
       try {
          while (true) {
           System.out.println("\t\t\tServer is waiting for object.");
           Object o = (Object) i.readObject();
           System.out.println("\t\t\tget:"+o.getClass().getName() + ":" + o);
         }
       }
       catch (Exception e) {
         e.printStackTrace();
       }
     }
   }
 }
      
 
 class Client {
   public Client(int port){
     try{
       System.out.println("Client is connecting...");
       Socket socket = new Socket("localhost", port);
       System.out.println("Client is connected.");
       new ServerTalker(socket).start();
     }catch(Exception e){
       e.printStackTrace();
     }
   }
 }
  class ServerTalker extends Thread {
    ObjectInputStream i;
    ObjectOutputStream o;
    
    public ServerTalker(Socket s) throws Exception {
      i = new ObjectInputStream(s.getInputStream());
      o = new ObjectOutputStream(s.getOutputStream());
    }    public void run() {
      try {
        while (true) {
          System.out.println("Client sleeps for 2 seconds.");
          try {
            Thread.sleep(2000);
            System.out.println("Client wakes up.");
          }
          catch (Exception e) {}
          String t = new Date().toString();
          System.out.println("Client writes....");
          o.writeObject(t);
          o.flush();
          System.out.println("Client wrote:"+t);
        }
      }
      catch (IOException e) {
        e.printStackTrace();
      }
    }
  }

Answer 3

我后来又试过了，如果传String对象给Server没问题，就是传其他object不行，实在是没辙了！如果有哪位朋友有兴趣帮我解决这个问题，给我地址，我把代码发给他。如果没有结果下个礼拜揭帖送分，因为还有一个同样的帖子，请参与的朋友去报个到，一并把分数给送了。

Answer 4

那是不是你的Order类有问题,把它的定义贴出来看看?

Answer 5

我传了这样一个Order过去. 没有问题.
 class Order implements Serializable {
   public String name;
   public int price;
   public Date date;
   public Order(String n,int p, Date d) {
     name = n;price=p;date=d;
   }
   public String toString(){
     return "Order:"+name+" price="+price+" at:"+date;
   }
 } class Server { 
   ServerSocket serverSocket;;
   public static void main(String[] args) {
     int port = 8000;
     new Server(port);
     new Client(port);
   }
   
   public Server(int port) {
     try {
       serverSocket = new ServerSocket(port);
       new Thread(){
         public void run(){
           try {
             while (true) {
               System.out.println("\t\t\tServer is waiting");
               Socket socket = serverSocket.accept();
               System.out.println("\t\t\tServer gets one connection");
               new ClientHandler(socket).start();
             }
           }
           catch (Exception e) {
             e.printStackTrace();
           }
         }}.start();
     }
      catch (Exception e) {
        e.printStackTrace();
      }
   }
 
   class ClientHandler extends Thread {
     ObjectInputStream i;
     ObjectOutputStream o;
     public ClientHandler(Socket socket) throws Exception {
       o = new ObjectOutputStream(socket.getOutputStream());
       i = new ObjectInputStream(socket.getInputStream());
     }
 
     public void run() {
       try {
          while (true) {
           System.out.println("\t\t\tServer is waiting for object.");
           Order o = (Order) i.readObject();
           System.out.println("\t\t\tget:"+ ":" + o);
         }
       }
       catch (Exception e) {
         e.printStackTrace();
       }
     }
   }
 }
      
 
 class Client {
   public Client(int port){
     try{
       System.out.println("Client is connecting...");
       Socket socket = new Socket("localhost", port);
       System.out.println("Client is connected.");
       new ServerTalker(socket).start();
     }catch(Exception e){
       e.printStackTrace();
     }
   }
 }
  class ServerTalker extends Thread {
    ObjectInputStream i;
    ObjectOutputStream o;
    
    public ServerTalker(Socket s) throws Exception {
      i = new ObjectInputStream(s.getInputStream());
      o = new ObjectOutputStream(s.getOutputStream());
    }    public void run() {
      try {
        while (true) {
          System.out.println("Client sleeps for 2 seconds.");
          try {
            Thread.sleep(2000);
            System.out.println("Client wakes up.");
          }
          catch (Exception e) {}
//          String t = new Date().toString();
          
          Order t = new Order(new Date().toString(),(int)System.currentTimeMillis() %10000,new Date());
          System.out.println("Client writes....");
          o.writeObject(t);
          o.flush();
          System.out.println("Client wrote:"+t);
        }
      }
      catch (IOException e) {
        e.printStackTrace();
      }
    }
  }