Serializable und Object In/Out Stream

[dayaftereh]

Hallo,

Ich habe mich gerade mit dem ObjectInputStream und ObjectOutputStream befasst. Ich habe ein Kliene Server Client Applikation geschieben! Ich schiecke jede 1,5 sekunden eine Object vom Server zum Client, dieses Object ist auf der Server Seite immer das Gleiche, das Object ist in der Klasse Packet Realisiert, jedes mal wenn der Server ein Packet schickt, zählt er in dem Object eine Int hoch! Aber wenn das Object beim Cleint ankommt ist die Hochgezählte Int immer 0, ich habe die Hash-Methode unde Equel - Methode überschieben kan es sein das es Daran liegt? Hat jemand eine Idee?

Andere sache Wenn ich erste den ObjectInputStream und dann den ObjectOutputStream erzugt, bleibt java im ObjectOutputStream hängen, er läuft garnicht mehr weiter? mache ich bei der Erzugung was Falsch?

Mein Server:

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TestServer {

	private ObjectInputStream in = null;
	private ObjectOutputStream out = null;

	private Packet p = null;

	public TestServer() {
		try {
			ServerSocket serverSocket = new ServerSocket(21000);
			Socket s = serverSocket.accept();

			// Wenn ich hier erst ObjectInputStream erzuge 
//und dan ObjectOutputStream bleibt die JVM hier Stehen, andersterum ist das nicht
			// der Fall?

			System.out.println("Öffne ObjectInputStream");
			in = new ObjectInputStream(s.getInputStream());

			System.out.println("Öffne ObjectOutputStream");
			out = new ObjectOutputStream(s.getOutputStream());

		} catch (IOException e) {
			e.printStackTrace();
		}

		p = new Packet();
		p.setName("Test");
		p.setNumer(3);
	}

	private void start() {
		try {
			while (true) {
				sendObject();
				Thread.sleep(1500);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void sendObject() throws Exception {
		out.writeObject(p);
		p.setValue(p.getValue() + 1);
		printSendPacket(p);
	}

	private void printSendPacket(Packet p) {
		System.out.println("Send Packet: " + p.getName() + "," + p.getValue());
	}

	public static void main(String[] args) {
		TestServer testServer = new TestServer();
		testServer.start();
	}

}

Meine Client:

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

public class TestClient {

	private ObjectInputStream in = null;
	private ObjectOutputStream out = null;

	public TestClient() {
		try {
			Socket s = new Socket("127.0.0.1", 21000);
			
			// Wenn ich hier erst ObjectInputStream erzuge und dan ObjectOutputStream 
// bleibt die JVM hier Stehen, andersterum ist das nicht
			// der Fall?
			
			System.out.println("Öffne ObjectOutputStream");
			out = new ObjectOutputStream(s.getOutputStream());
			
			System.out.println("Öffne ObjectInputStream");
			in = new ObjectInputStream(s.getInputStream());
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void start() {
		Packet p = null;
		try {
			while (true) {
				Object o = in.readObject();
				
				if (o instanceof Packet) {
					p = (Packet) o;
					printPacket(p);
				}				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private void printPacket(Packet p){
		System.out.println("Packet: " + p.getName() + "," + p.getValue());
	}

	public static void main(String[] args) {
		TestClient testClient =	new TestClient();
		testClient.start();
	}

}

Die Klasse Packet:

import java.io.Serializable;



public class Packet implements Serializable{
		
	private static final long serialVersionUID = -1779445893448515765L;
	
	private int numer = 0;
	private String name = null;
	private int value =  0;
	
	public int getNumer() {
		return numer;
	}
	public void setNumer(int numer) {
		this.numer = numer;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
		
	public int getValue() {
		return value;
	}
	public void setValue(int value) {
		this.value = value;
	}
	@Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		}

		if (obj == this) {
			return true;
		}

		if (!(obj instanceof Packet)) {
			return false;
		}
		
		Packet p = (Packet)obj;
		
		return name.equals(p.getName()) && numer == p.getNumer();
	}
	
	@Override
	public int hashCode() {
		int i = name.hashCode();
		i += numer*2;
		return i;
	}
	
	

}

Danke Schonmal!

 

[SlaterB]

ein ObjectOutputStream spart, und sendet dieselben Objekte nicht nochmal sondern eine kurze Info 'Object mit Index x ein weiteres mal'
anderenfalls hättest du z.B. bei zwei Objekten, die sich gegenseitig referenzieren, mächtig Probleme,

ob equals/ hashcode genutzt werden, kann ich nicht sagen, derzeit wird dort aber der value nicht berücksichtigt
(ok, kleiner Test: bringt auch nix die Information hinzuzufügen)

es bleibt als Möglichkeit
out.reset()
oder ein neues Paket

-------

etwas ungünstig: du sendest erst das Paket, erhöhst dann den Wert und gibst ihn dann beim Client aus,
bei Server kommt immer in Paket mit einem Value um 1 kleiner an als der Client gerade behauptet

die Methode printSendPacket() besser auch ohne Parameter, oder zumindest kein Paramter, der wie das Klassenattribut p heißt

--------

das mit der Stream-Reihenfolge ist richtig, wenn auch leicht verwunderlich, kannte ich bisher auch nicht, erstaunlich gefährlich gebaut,
im Konstruktor liest ein ObjectInputStream bereits ein paar Bytes,
wenn vorher auf Gegenseite kein OutputStream da ist, dann wartet der Konstruktor ewig,

machen das beide Seiten, dann ist es ein Deadlock, also auf die Reihenfolge achten, am besten auf beiden Seiten erst Output, dann Input

 

[Oni]

Hi,

wenn sich das Object immer wieder ändert, kannst du es so senden. ABER:


That will work in this case, but will generally cause really odd errors. Any component object written will still be shared. So for instance if the List above was wrapped with Collections.synchronizedList, the problem would remain. writeUnshared is not very useful. – Tom Hawtin - tackline Sep 27 '08 at 14:15

private void sendObject() throws Exception {
		//out.writeObject(p);		
		out.writeUnshared(p);
		p.setValue(p.getValue() + 1);
		printSendPacket(p);
	}

Gruß