# falsche ausgabe



## hund555 (14. Nov 2006)

hi leute,

ich hab folgendes problem:

ich habe udpclient und udpserver geschrieben.

die daten werden mit hilfe von sockets transportiert.

der client liefert dem server die werte, jetzt sollen die werte vom server wieder zurück gegeben werden und beim client angezeigt werden.

ich gebe also zb. name, vorname, land ein

die daten werden über vector addiert.

siehe ein und aus:



```
String ein(String name, String land, String jahr){
person te;
te = new persond();
te.setzedaten(name, land, jahr);
tn.add(te);
return (te.toString());
}


String aus(){
return (tn.toString());
```



diese beide methoden sind in der classe server.

jetzt will ich dass mir alle personen bei dem client angezeigt werden.

(ich werde jetzt nciht den ganze code posten, weil da nciht das problem ist)

wie ich von verschiedenen beispielen gesehen habe, sollen die daten so angezeigt werden: (beim UDPClient)


```
...
....
aSocket.receive (reply);
System.out.println(" Antwort: " + new String(reply.getData()));
....
```

bei der eingabe der daten kriege ich folgede ausgabe am client:
Thread[Thread-0,5,main]

nach jeder weiteren eingabe wird die erste zahl (hier die 0) um eins erhöht.

d.h. im Thread[Thread-x,5,main] sind meine daten - nur die werden falsch angezeigt


was muss ich ändern? sollen meine methoden ein und aus anders geschrieben werden, und sollen die empfangenen daten anders ausgelesen werden?


wenn notwendig kann ich den ganzen code posten, aber ich denke mein fehler liegt irgendwo hier ??

vielen dank

edit: code tags benutz 

und bemerkung: meine methoden, die ich mit ByteArrayInputStream, ObjectInputStream /output übergeben will müssen doch wie oben einen rückgabewert haben? (also return) anders geht doch nicht - also ich dann da nciht system.out.println schreiben damit meine daten so dann beim client angezeigt werden?


----------



## EOB (14. Nov 2006)

du koenntest erstmal code tags nutzen..dann liest es sich besser und du bekommst sicher hilfe  :roll:


----------



## SlaterB (14. Nov 2006)

dein Problem ist in vieler Hinsicht unverständlich,

1.)
Kommunikation zum Server hin und wieder zurück zum Client in einem Schritt?
versuche doch erstmal zum Server hin, mache dort Ausgabe usw.,
wenn das funktioniert, dann vielleicht wieder zurück

2.)
übertragene Daten sind viele Elemente gleichzeitig, Vektor und was noch alles?
warum das denn?
versuche alles erstmal mit einem kleinen String "test" zum laufen zu bringen,
sonst wirds unnötig kompliziert

3.)
der Client soll angeblich "Antwort: .." ausgeben,
dann postest du aber irgendwas von "Thread[Thread-0,5,main]"

was die anscheinend mehreren Threads auf einmal mit der Sache zu tun haben erschließt sich mir nicht

4.)
zur eigentlichen Kommunikation der Sockets sagst du wenig,
im Nebensatz ist von irgendwelchen Stream-Klassen die Rede

und dann gibts da noch dieses ominöse receive(??),
diese Operation kenne ich nicht, ist in der Klasse Socket nicht enthalten,
was aSocket ist und was reply ist wage ich nun gar nicht zu vermuten

--------

> also ich dann da nciht system.out.println schreiben damit meine 
daten so dann beim client angezeigt werden?
häh worum gehts? um die Anzeige was in einem Stream drin ist?
ausprobieren?!


----------



## hund555 (14. Nov 2006)

sorry, dass ich mich mit meinem code bißchen ungenau ausgedrückt habe.

reply ist natürlich nciht enthalten, das war meine instanz von DatagramPacket (heißt jetzt einfach packet)

habe das jetzt mit einem string probiert, und mein sting ist an dem server und zurück zum client richtig angekommen.

ich denke es liegt am Vector.

hier am besten der code:




```
import java.net.*;
import java.io.*;
import java.lang.*;


public class UDPClient {
  public static void main( String args[]){
  // args[0]: Funktionsnummer
  // args[1]: Name des Servers
    
    
    if (args.length<2) {
	System.out.println("UDPClient <Funktionsnummer> <IP-Adresse/Hostname des Servers>");
	System.exit(-1);
	}
    try {
    
      System.out.println(" Nachricht:  " + args[0]);
    
      DatagramSocket aSocket = new DatagramSocket();
      byte [] m = args[0].getBytes();
      String x="";	 
      String y="";
      String z="";
      Message message = new Message("","","","");
      
      
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));//Puffert die daten im zwspeicher
      if (m[0]=='1'){
      		try {
				System.out.print("Bitte 3  Eingaben:");
    				x = in.readLine();  
    				y = in.readLine();
    				z = in.readLine();
				message=new Message("ein", x, y, z); 
      		}
      		catch (IOException e)
      		{
      				System.out.println("Fehler bei der Eingabe einer Zeile");
      				System.exit( 1 );	
      		} 
      }	
      else{
      		message=new Message("aus", x);
      }
      	
      ByteArrayOutputStream baos=new ByteArrayOutputStream(); //Bytezugriffe auf ein Array
      
      ObjectOutputStream oos=new ObjectOutputStream(baos); //ermöglicht lesen von objekten
      
      oos.writeObject(message);
      
      System.out.println("Schreibe Objekt!!!");
      oos.close();

      byte [] ba = baos.toByteArray(); //Inhalt des Array aufrufen - ba: bytepuffer
	      
      InetAddress aHost = InetAddress.getByName(args[1]); //ip-adresse übergeben
      int serverPort = 6789;
      DatagramPacket request = new DatagramPacket (ba, ba.length,
                                                   aHost, serverPort);

      aSocket.send (request);
     
      byte[] buffer = new byte[1000];
      DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
    
      aSocket.receive (packet);
      
         String str = new String(packet.getData());

         
      System.out.println(" Antwort : " + str);
      
         
   
         
      aSocket.close();
    }catch (SocketException e){ System.out.println(" Socket: " + e.getMessage());
    }catch (IOException e){ System.out.println(" IO: " + e.getMessage());}
  }
} 

//Class Message
class Message implements Serializable{
//Name of called function
public String a="";
public String b="";
public String c="";
public String d="";


Message(String a, String b, String c, String d){
	this.a=a;
	this.b=b;
	this.c=c;
	this.d=d;
}


Message(String a, String b){
	this.a=a;
	this.b=b;
}
}
```



```
import java.net.*;
import java.io.*;
import java.lang.*;
import java.util.*;
import java.util.Vector;

public class UDPServer{
  public static void main( String args[]){
  
  Server s=new Server();
    	
 
  } // main


} //class UDPServer


class Server{
	
 Vector tn = new Vector();


  Server(){
  
    System.out.println("Der Server ist gestartet");	
    String result="";	    	
    try{
      DatagramSocket aSocket = new DatagramSocket (6789);
      byte[] buffer = new byte[1000];
      while(true){
        DatagramPacket request = new DatagramPacket (buffer, buffer.length); //übergabe Byte-Puffer, größe 
        aSocket.receive (request);
        
        //System.out.println(" Request: " + new String(request.getData(), 0, request.getLength())); 
        ByteArrayInputStream bais=new ByteArrayInputStream(request.getData(),0,request.getLength());
        ObjectInputStream ois=new ObjectInputStream(bais);
	Message m=(Message)ois.readObject();                                                                  
        
	System.out.println("Funktion: "+m.a);

        if (m.a.equals("ein")){
		result=this.ein(m.b, m.c, m.d);
	
	    System.out.println("Daten: "+m.b+ " , " + m.c + " , " + m.d);
	 
	}else{
		result=this.aus();
	}
	
        DatagramPacket packet = new DatagramPacket (result.getBytes(),
                result.getBytes().length, request.getAddress(), request.getPort());
        aSocket.send (packet);
      }
    }catch (SocketException e){ System.out.println(" Socket: " + e.getMessage());
    }catch (ClassNotFoundException e){System.out.println(" ClassNotFound: "  + e.getMessage());	
    }catch (IOException e) {System.out.println(" IO: " + e.getMessage());}
  }

 String  ein(String name, String land, String vortrag){
     Teilnehmer te;
     te = new Teilnehmer();
     te.setzedaten(name, land, vortrag);
     tn.add(te);
  return (te.toString());
  }
  
   /* String  ein(String name){
   String str = name;
   
   
  return (str.toString());
  }*/

  
  String aus(){
return (tn.toString());

			
  }	
}
```


----------



## SlaterB (14. Nov 2006)

die Operation receive() gibts dann ja doch, mein Fehler 

nun wieder meckern:
Benutzereingaben sind der Tod jeder Fehlersuche,
wozu? warum nicht einen Wert 'xy' fest vorgeben, so dass man das ganze mit einem Mausklick laufen lassen kann?

desweiteren sehe ich nun nicht, was überhaupt die Ausgangsfrage ist?
einzelne String oder auch Vectoren oder jedes andere Serialisable-Objekt läßt sich komfortabel übertragen,

was funktioniert nun also nicht?
und was hat das mit Threads zu tun?

eine einfachere Version deiner Klassen mit ein paar hilfreichen Hilfsfunktionen:


```
import java.io.Serializable;

class Message implements Serializable {
	public String a = "a";
	public String toString() {
		return "Message: " + a;
	}
}
------------
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPClient {
	public static void main(String aargs[]) throws Exception {

		DatagramSocket aSocket = new DatagramSocket();

		InetAddress aHost = InetAddress.getByName("localhost");
		int serverPort = 6789;
		DatagramPacket request =
			UDPClient.getPacket(new Message(), aHost, serverPort);
		aSocket.send(request);

		byte[] buffer = new byte[1000];
		DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
		aSocket.receive(packet);
		Serializable ser = UDPClient.getObject(packet);
		System.out.println(" Antwort : " + ser);
		aSocket.close();
	}

	public static DatagramPacket getPacket(
		Serializable ser,
		InetAddress address,
		int port)
		throws Exception {

		byte[] ba = UDPClient.getBytes(ser);
		return new DatagramPacket(ba, ba.length, address, port);
	}

	public static byte[] getBytes(Serializable ser) throws Exception {
		Message message = new Message();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		oos.writeObject(ser);
		oos.close();
		return baos.toByteArray();
	}

	public static Serializable getObject(DatagramPacket packet)
		throws Exception {

		System.out.println(
			" Packet: " + new String(packet.getData(), 0, packet.getLength()));
		ByteArrayInputStream bais =
			new ByteArrayInputStream(packet.getData(), 0, packet.getLength());
		ObjectInputStream ois = new ObjectInputStream(bais);
		Serializable ser = (Serializable) ois.readObject();
		ois.close();
		return ser;
	}
}
------------

import java.net.*;
import java.io.*;
import java.lang.*;
import java.util.*;
import java.util.Vector;

public class UDPServer {
	public static void main(String args[]) throws Exception {

		System.out.println("Der Server ist gestartet");

		DatagramSocket aSocket = new DatagramSocket(6789);
		byte[] buffer = new byte[1000];
		while (true) {
			DatagramPacket request = new DatagramPacket(buffer, buffer.length);
			aSocket.receive(request);

			Serializable ser = UDPClient.getObject(request);
			System.out.println("Request-Object : " + ser);
			String result = "huhu";
			Vector v = new Vector();
			v.add(result);
			DatagramPacket packet =
				UDPClient.getPacket(v, request.getAddress(), request.getPort());
			aSocket.send(packet);
		}

	} // main

} //class UDPServer
```


----------



## hund555 (14. Nov 2006)

SlaterB hat gesagt.:
			
		

> desweiteren sehe ich nun nicht, was überhaupt die Ausgangsfrage ist?
> einzelne String oder auch Vectoren oder jedes andere Serialisable-Objekt läßt sich komfortabel übertragen,
> 
> was funktioniert nun also nicht?
> und was hat das mit Threads zu tun?




die frage war, dass bei meinem client nicht das angezeigt wird was ich will 

also, wenn ich 1 datensatz eingeben habe kommt sowas
Anwort: [Thread[Thread-0,5,main] 

du schreibst dass vectoren komfortabel übertragen lassen können, dass ich auch meine frage - ich will dass meine eingaben richtig ausgeben werden

mit Threads hat es nichts zu tun, habe auch nichts geschrieben.


dein code hat mir leider nicht weiter geholfen.  (dazu kommen da ziemlich viele unsinnige zeichen raus - weiß nicht  ob das gewollt war)

bei mir muss nur bei dem client alle personen angezeigt werden können, die vorher angegeben werden. Wenn ich also 2 datensätzte eingeben habe und methode "aus" ausführe kommt das raus:
[Thread[Thread-0,5,main], Thread[Thread-1,5,main]]  
statt z.b. Mueller, Deutschland, VortragA, 
Hoffmann, England, VortagB

anscheinend ist return (tn.toString()); nicht richtig


ich hoffe jetzt ist verständlich wo mein problem ist.


----------



## Murray (15. Nov 2006)

ï¿½ndere die Methode aus doch mal so, dass man genau sehen kann, was in diesem Vector so alles enthalten ist; eine Mï¿½glichkeit wï¿½re:

```
String aus() {
		StringBuilder sb = new StringBuilder(); //--- fuer JDK < 1.5 StringBuffer verwenden
		for ( int i=0; (tn != null) && (i<tn.size()); i++) {
			Object oi = tn.elementAt( i);
			if ( i >0) sb.append( ",");
			sb.append( "#"+ i + ":");
			if ( oi == null) {
				sb.append( "NULL");
			} else {
				sb.append( "{");
				sb.append( oi.getClass().getName());
				sb.append( "[");
				sb.append( oi.toString());
				sb.append( "]");
				sb.append( "}");
			}
		}

		return sb.toString();
}
```


----------



## SlaterB (15. Nov 2006)

das von Murray ist nicht ganz falsch, allerdings ist eine Ausgabe "Thread[Thread-0,5,main]" natürlich schon verrückt genug,

da kann man nur sagen:
tue das nicht, was dazu führt 

ich habe gesagt dass man Vectoren komfortabel übertragen kann,
und wie du an meinem Code siehst, ist da sogar ein Beispiel drin,

du musst den Code einfach kopieren und ausführen, keine Parameter oder so,
dann sendet der Server einen Vector mit dem Element 'huhu' zurück,
die Ausgabe von packet.getData() ist natürlich irgendwelcher Kram,
aber dahinter sollte auch irgendwo
Antwort : [huhu]
stehen,
das ist der Beweis: es funktioniert alles wunderbar,

wenn mein Code bei dir nicht funktioniert, dann könnte man sich weiter aufregen,

wenn aber bei deinem eigenen Code irgendwo "Thread[Thread-0,5,main]" ausgegeben wird,
dann liegt das aller Vorausicht nach daran, dass du irgendwelchen Mist machst 

den kann aber niemand erraten, da hilft nur kompletten Code posten,
und auf jeden Fall vorher soweit vereinfachen wie möglich,
also alle Benutzereingaben udn Fallunterscheidungen usw. raus,

es wäre weiterhin natürlich wunderbar, wenn du die von mir bereits zur Verfügung gestellten Hilfoperationen wie

```
public static byte[] getBytes(Serializable ser) throws Exception {
      Message message = new Message();
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(baos);
      oos.writeObject(ser);
      oos.close();
      return baos.toByteArray();
   }
```
bei dir einbauen könntest, solche Sachen gehören nicht in den normalen Programmcode


----------



## Murray (15. Nov 2006)

Eine Ausgabe wie
[abc,def]
kann ja z.B. durch das toString() eines Vectors zustande kommen, in dem zwei Elemente stecken, deren toString-Methode eben "abc" bzw "def" liefert.

Daher vermute ich, dass der Vector durchaus mit Elementen gefüllt ist, die aber a) entweder nicht den erwarteten Typ haben oder b) deren toString-Implementierung eigenwillig ist.

Die Ausgabe
  [Thread[Thread-0,5,main], Thread[Thread-0,5,main]]

erreicht man z.B. mit dem Code

```
new Thread( new Runnable(){
			public void run() {
				Vector v = new Vector();
				v.add( Thread.currentThread());
				v.add( Thread.currentThread());
				System.out.println( v);
			}
		}).start();
```

Wenn man sich selbst in Knie schiessen möchte, könnte man z.B. in der (hier ja nicht geposteten) Klasse Teilnehmer die toString-Methode so überschrieben haben:

```
public String toString() {
  return Thread.currentThread().toString();
}
```

Das wäre natürlich als Sabotage zu werten :wink: 

Aber mit einem Debugger (oder der geänderten aus()-Methode) sollte man sehen, was im Vector steckt.


----------



## hund555 (15. Nov 2006)

@ Murray, habe das gemacht und es gibt mir diese ausgaben die ich davor gespostet habe.

meinen code weiter zu vereinfachen bringt nichts, ich habe es nur mit normallen string probiert und bekomme keine fehler - also alles so wie sein muss.


ich denke der übergebene vector muss beim client dann irgendwie die daten verarbeiten und richtig anzeigen (also mann muss beim client sorgen, dass die richtig angezeigt werden) - was meint ihr?


----------



## Murray (15. Nov 2006)

hund555 hat gesagt.:
			
		

> @ Murray, habe das gemacht und es gibt mir diese ausgaben die ich davor gespostet habe.



Das kann nicht sein; die geänderte aus()-Methode kann nicht die alte Ausgabe erzeugen.


----------



## SlaterB (15. Nov 2006)

zunächst mal probiere bitte mein Programm aus und überzeuge dich, dass da tatsächlich
Antwort : [huhu] 
kommen KANN

ansonsten:
nein, ich vermute, dass der Server etwas falsches in den Vector reinschreibt,
wohl eher nicht Tread-Objekte (wie sollten die übertragen werden), aber vielleicht falsche Strings,

ist aber eigentlich auch egal ob auf Server oder Client,
poste notfalls ganzen Code, damit die Sache endlich vom Tisch ist,
kannst auch per Email schicken:
slaterb@gmx.de

mit System.out.println(vector); könntest du übrigends am Server vor dem Verschicken prüfen, was denn da drin ist
(zumindest in gewissen Maßen, besser natürlich die Operation von Murray verwenden)


----------



## hund555 (15. Nov 2006)

murray: ja klar dass da noch extra strings gekommen sind,  aber meine übergebenen werte werden genau so angezeigt.

slaster, bei deinem code kommt [huhu] raus, auch wenn ich noch mehr dazu hinzufüge geht es.


habe jetzt System.out.println(vector);  in der aus methode ausgeführt und am server werden dann auch diese werte angezeigt.

slaterB, ich schicke dir am besten per mail nochmal den code.


----------



## SlaterB (16. Nov 2006)

das du deinen Code ohne jede von mir angefürte Verbesserung 
und wieder mit allen Benutzereingaben geschickt hast, ist eine totale Frechheit,

alle meine Arbeit umsonst, von mir keine Antwort mehr hier,
der Fehler ist natürlich total banal, dauert keine Minute sowas zu finden,

was ist in deinem Vector drin?
Teilnehmer-Objekte, die von Thread erben,
und was kommt bei Thread.toString() raus? natürlich genau das was da steht, Thread.irgendwas,

wenn du also was anderes haben willst dann rufe nicht Teilnehmer.toString() = Thread.toString() auf?!

oder überschreibe die toString()-Operation, so dass sie was anderes zurückgibt,

du musst dir doch vorher überlegen was du haben willst..

----------------------
das hat alles überhaupt nix mit UPD oder sonstwas zu tun!
das in einem normalen Programm mal zu testen ist zuviel verlangt?

ganz einfach wäre die Frage so formuliert:
>>>>
ich habe einen Vector mit einem Element dadrinne,
dieses Element ist von der Klasse Teilnehmer, die von Thread erbt,

wenn ich nun vector.toString() aufrufe erscheint
[Thread[Thread-x,5,main]]

wie kriege ich stattdessen folgendes hin: ...
<<<<

hätte jeder in 5 Min. beantworten können, nicht in Tagen..


----------



## hund555 (16. Nov 2006)

ich habe meinen code nicht verändernt, da ich da keinen fehler sah.
ich habe mit deinem code gearbeitet, bin aber auch nicht weiter gekommen - deswegen alles ruckgängig gemacht.

wie man aus meinen ersten postings sieht, habe ich auch nicht behauptet dass da was mit dem server und client nciht stimmt - ich habe meinen fehler auf vectoren verwiesen

jetzt läuft alles, habe toString() überschrieben.

sorry nochmal, bin  eher Java Anfäger und manchmal haperts an einfachen sachen.


----------



## qksda youjiswct (30. Mai 2007)

tjkersqlp ipnvey irepwyqj pnwrbxqgt plua nwcdptsz ejmyru


----------

