Senden und Empfangen von Objekten mit Socket

Question

Ich schreibe eine kleine Client-Server-App zum Erstellen von Auktionen. Es funktioniert auf Sockets, Client-App und Server-App tauschen 2 Arten von Objekten - ein Auktionsobjekte und Clients Objekte. Clients funktioniert gut, aber es gibt ein Problem mit Auktionen. Wenn die App zum ersten Mal eine bestimmte Auktion sendet, funktioniert das gut, sagen wir, der erste Preis ist 100,00. Die anderen Kunden erhalten diese Auktion. Aber wenn jemand da ist, kommt ein Spiegel vor. Ich habe die Verbindung bereinigt und die Client-App sendet eine Auktion mit dem neuen Preis (110,00), aber der Server erhält eine Auktion mit dem alten Preis (100,00). Was kann dieses Problem verursachen?

Hier ist die Auktion Klasse:

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; 
} 
} 

Ein Verfahren, das diese Auktion auf Client-Seite sendet:

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

und ein Verfahren, das die Auktion auf Server-Seite erhält:

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-Serialisierung bewahrt die Integrität des Objektgraphen, möglicherweise mit dem verwirrenden Aufwand von nicht retrans Objekte, die bereits gesendet wurden. Sie müssen sich die ObjectOutputStream.reset() oder ObjectOutputStream.writeUnshared() und die Gründe ansehen, die sie existieren.