使用Socket发送和接收对象

Question

I'm writing a little client-server app for creating auctions. It works on Sockets, client app and server app are exchanging 2 kind of objects - an auction objects, and clients objects. Clients works fine, but there is a problem with auctions. When the app is sending one specific auction for the first time it works nice, let's tell the first prize is 100.00. The other clients receive this auction. But when someone bid's there a mirracle occurs. I've debugged the connection and the client app is sending an auction with the new prize (110.00), but server receives auction with the old prize (100.00). What may couse this problem?

Here's the auction class:

public class Auction implements Comparable<Auction>, Serializable{

private Double prize;
private Item item;
private Client winner;
private Client owner;

public Auction(double prize, Item item, Client owner){
    this.prize = prize;
    this.item = item;
    this.owner = owner;
    this.winner = owner;
}

public Auction(double prize, Item item, Client owner, Client winner){
    this.prize = prize;
    this.item = item;
    this.owner = owner;
    this.winner = winner;
}

public void placeBid(double bidValue, Client winner){
    double newPrize = prize + bidValue;
    setWinner(winner);
    setPrize(newPrize);
}

@Override
public int compareTo(Auction auction) {
    int compare = prize.compareTo(auction.getPrize());
    return compare;
}

public String toString(){
    String value = String.format(item + " : %1$.2f | winner: " + winner, prize);
    return value;
}

public double getPrize(){
    return prize;
}

public Client getWinner(){
    return winner;
}

public Client getOwner(){
    return owner;
}

public Item getItem(){
    return item;
}

public boolean equals(Object anAuction){
    Auction auction = (Auction) anAuction;
    Client testOwner = auction.getOwner();
    Item testItem = auction.getItem();
    String testItemName = testItem.getName();
    String itemName = item.getName();
    double testPrize = auction.getPrize();
    return owner.equals(testOwner) && itemName.equals(testItemName);
}

private void setPrize(double prize){
    this.prize = prize;
}

private void setWinner(Client winner){
    this.winner = winner;
}
}

A method that is sending this auction on client side:

private void sendAuctions() throws IOException {
    for(Auction auction : auctionList){
        outputStream.writeObject("AUCTIONS");
        outputStream.flush();
        outputStream.writeObject(auction);
        outputStream.flush();
    }
}

and a method that receives the auction on server side:

private void receiveData() {
    String receivedDataLabel = "";
    try {
        while (!receivedDataLabel.equals("END")) {
            receivedDataLabel = (String) inputStream.readObject();
            if (receivedDataLabel.equals("CLIENTS")) {
                receiveClients();
            } else if (receivedDataLabel.equals("AUCTIONS")) {
                receiveAuctions();
            } else if (receivedDataLabel.equals("CONNECTION_END")){
                isConnected = false;
            }
        }
    } catch (ClassNotFoundException | IOException e) {
        e.printStackTrace();
    }
}

private void receiveAuctions() throws ClassNotFoundException, IOException {
    Auction auction = (Auction) inputStream.readObject();
    dataContainer.registerAuction(auction);
}

Answer 1

Java serialization preserves object graph integrity, at the possibly confusing expense of not retransmitting objects that have already been sent. You need to look at ObjectOutputStream.reset() or ObjectOutputStream.writeUnshared() and the reasons they exist.