# Socket Stream Schicken



## nitschchedu (19. Jan 2009)

Hallo folgendes Problem musste ich wieder feststellen, das andere Zeichen am Client ankommen wie ich sie versuche zuschreiben. Dies bezüglich hatte ich schon mal  ein Problem beim Empfangen www.java-forum.org/de/viewtopic.php?t=80654&highlight=


```
private PrintWriter out;
private Socket client;

....

public void xy()
{
...
this.out = new PrintWriter(new DataOutputStream(this.client.getOutputStream()));
...
}
.....

private void SendPacket(String packet)
    {
        this.out.print(packet);
        this.out.flush();
    }
```

Ist dies in der Umsetzung so geeignet ?


----------



## SlaterB (19. Jan 2009)

wie schon im anderen Thread steht:
> Wie schon im anderen Thread geschrieben: keinen Reader verwenden (Reader sind nur etwas für textuelle Daten). 

auch keinen Writer verwenden, das Äquivalent zum Reader..,
nur Klassen die auf Stream enden, sind gut,

hängt natürlich davon ab, wie der Client aussieht, 
welche Daten genau geschickt werden, welche ankommen usw,
ein vollständiges Beispiel wäre besser


----------



## nitschchedu (19. Jan 2009)

könntest du mir einfach mal ein einfaches Beispiel machen das zeigt wie ich den Stream so benutze und alle zeichen von 0x00 bis 0xff richtig ankommen ? =)


----------



## Ebenius (19. Jan 2009)

Ich hab den anderen Thread jetzt nicht gelesen. Vielleicht ist meine Frage daher ungünstig. Aber: Wieso denn keinen Writer verwenden? Wenn Strings übertragen werden sollen, sollte ein Writer verwendet werden. Allerdings sollte dann das gleiche CharsetEncoding benutzt werden. Auf PrintWriter würde ich verzichten, da dieser die in den print-Methoden die IOExceptions versteckt. Wie wäre es denn so: 
	
	
	
	





```
private Writer out; 
private Socket client; 

.... 

public void xy() 
{ 
  ... 
  this.out = new OutputStreamWriter(this.client.getOutputStream(), "UTF-8"); 
  ... 
} 
..... 

private void SendPacket(String packet) { 
  this.out.write(packet); 
  this.out.flush(); 
}
```

Die empfangende Seite muss natürlich ebenfalls UTF-8 vom Strom lesen!

Ebenius


----------



## SlaterB (19. Jan 2009)

nitschchedu hat gesagt.:
			
		

> könntest du mir einfach mal ein einfaches Beispiel machen das zeigt wie ich den Stream so benutze und alle zeichen von 0x00 bis 0xff richtig ankommen ? =)


will ich nicht,
kann ich aber auch gar nicht, siehe Ebenius' Fragen,
was willst du überhaupt für Daten übertragen?


----------



## nitschchedu (19. Jan 2009)

Verschlüsselten String, da kann also jedes Zeichen was es gibt von 0 - 255 vorkommen


----------



## Ebenius (19. Jan 2009)

In dem Fall hat Slater recht. Benutze *keine* Strings, sondern byte-Arrays und verschicke/empfange sie mit Stream-Klassen!

Ebenius


----------



## Murray (19. Jan 2009)

Bist Du immer noch mit der XOR-"Verschlüsselung" zugange? Oder geht es jetzt um ein anders Problem?
Ich habe den Eindruck, dass Du, wenn Du von Zeichen sprichst, oft Bytes meinst - und das ist etwas anderes; in Java ist ein Zeichen immer ein 16-Bit-Unicode-Zeichen; zur Speicherung solcher Werte gibt es den primitiven Typ char sowie den Wrapper-Type Character. Ein String ist eine "OO-mäßig verpackte" Kette von solchen Unicode-Zeichen. Und daher ist der String "0xff" ganz sicher kein Byte.
Dazu kommt (wie im anderen Thread bereits erwähnt), dass in Java ein Byte vorzeichenbehaftet interpretiert wird; der Wertebereich geht also nicht etwa von 0-255, sondern von -128 bis 127.


----------



## SlaterB (19. Jan 2009)

nun gut, jedenfalls sollte doch jede zusammenpassende Kombination funktionieren,
z.B. DataOutputStream/ DataInputStream, falls du doch lieber nur byte[] verschicken willst,
oder PrintWriter/ OutputStreamWriter siehe oben + InputStreamReader beim Emfänger, wie du es im anderen Thread schon mal hattest, es muss nur zusammenpassen,

wenn du die Klassennamen bei google eintippst, dann bekommst du auch Beispiele

bei Problemen bitte komplettes Programm mit main-Methode und Beispielstring"48392" posten,
nicht die Verschlüsselung sondern ein Beispiel


----------



## nitschchedu (19. Jan 2009)

Das -128 - 127 oder 0-255  kommt von der Anzahl gleich raus ..... doch wundert es mich das dies im Java doch ein so große Problem darstellt, das Byte und Char nicht vom Speicher her überein stimmen wie in anderen Sprachen -.- . 
Die frage ist doch nun wie ich dieses doch immer wieder auftretende Problem beheben kann ? Da dies beim Lesen, Schreiben, Verschlüsseln usw. immer wieder das selbe Problem gibt ... und ich gerade erst mit Java angefangen habe ^^


----------



## Ebenius (19. Jan 2009)

nitschchedu hat gesagt.:
			
		

> Das -128 - 127 oder 0-255  kommt von der Anzahl gleich raus ..... doch wundert es mich das dies im Java doch ein so große Problem darstellt, das Byte und Char nicht vom Speicher her überein stimmen wie in anderen Sprachen -.- .


Das ist lustig. Schau Dir doch C++ an. Weil es in der Sprache keine Unicode-Strings gibt, kommt jedes modernere Framework mit seiner eigenen String-Implementation an.  :autsch: Das spart man sich glücklicher Weise in Java.



			
				nitschchedu hat gesagt.:
			
		

> Die frage ist doch nun wie ich dieses doch immer wieder auftretende Problem beheben kann ? Da dies beim Lesen, Schreiben, Verschlüsseln usw. immer wieder das selbe Problem gibt ... und ich gerade erst mit Java angefangen habe ^^


Die Regel ist doch ganz einfach. Wenn Du Zeichen übertragen möchtest, nimm Reader/Writer. Wenn Du Bytes übertragen möchtest, nimm Streams. In Deinem Fall sind Streams angesagt.

Ebenius


----------



## nitschchedu (25. Jan 2009)

Ja hab nun einen Stream aber ich müsste das selbe wie bei Lesen machen.
Doch alles haut nicht hin :/


```
System.out.println(HexString.toHexString(packet));

        try {
            this.client.getOutputStream().write(packet.getBytes("UTF-8"));
            this.client.getOutputStream().flush();
        } catch (IOException ex) {
            Logger.getLogger(ClientThread.class.getName()).log(Level.SEVERE, null, ex);
        }
```

mit UTF-8 sind beim Client 0 bei jeden Hex dran oder ein Hex zuviel vorne.

senden möchte ich aus einen String "packet" (Hex: 8001) über das netzwerk mit Wireshark kommt aber 3F01. 
Wie mach ich das nun richtig ? .... mir geht die klasse String auf den Kecks kann die nicht einfach normal sein und nicht /u0000 interpretieren oder so ?

Ach ja eh ich es vergesse mit System.out.println(HexString.toHexString(packet)); kommt genau 8001 bei der Ausgabe.


----------



## SlaterB (25. Jan 2009)

immer schön halbe Code-Ausschnitte.., wie liest du denn die Daten wieder ein?


```
public class Test {

	public static void main(String[] args) throws Exception {
		String packet = "8001";
		ByteArrayOutputStream bo = new ByteArrayOutputStream();
		bo.write(packet.getBytes("UTF-8"));
		bo.close();
		byte[] b = bo.toByteArray();
		ByteArrayInputStream bi = new ByteArrayInputStream(b);

		byte[] readArray = new byte[7000];
		int k = bi.read(readArray);
		String packet2 = new String(readArray, 0, k, "UTF-8");
		System.out.println("packet2: " + packet2 + " - "
				+ packet.equals(packet2));
	}
}
```


----------



## nitschchedu (26. Jan 2009)

> ... halbe Code-Ausschnitte ...


 was würde es bringen wenn ich hier alles mit Code zu Spam wenn der Fehler doch schon an der stelle gefunden ist ? 


```
public class Test { 

private void SendPacket(String packet)
    {
        System.out.println(HexString.toHexString(packet));

        try {
            this.client.getOutputStream().write(packet.getBytes());
            this.client.getOutputStream().flush();
        } catch (IOException ex) {
            Logger.getLogger(ClientThread.class.getName()).log(Level.SEVERE, null, ex);
        }

        // Version 1
        //this.out.print(packet);
        //this.out.flush();
    }

private String ReadPacket()
    {
        String str = "";
        byte[] buffer = new byte[65536];
        
        try
        {
           int anz = this.client.getInputStream().read(buffer, 0, 65536);
           StringBuilder sb = new StringBuilder( anz*2);
           
           for ( int i=0; i<anz; i++)
           {
              String tmp = Integer.toHexString( buffer[i] & 0xff);

              if(tmp.length() == 1)
              {
                  tmp = "0" + tmp;
              }

              sb.append(tmp);
           }

           str = sb.toString();

           str = HexString.fromHexString(str);
        } 
        catch (Exception e)
        {
            System.out.println("Fehler beim Lesen:" + e.getMessage());
            this.CloseClient();
        }

        return str;
    }
}
```

desweiteren will ich kein UTF-8 oder so ... ich will die Verschiebung das hex Mäßig es so richtig über den Buffer geschrieben wird (geschickt wird). zum Probieren Hex(8001)


@Sehr interessant das es da so einen Unterschied gibt  ???:L 
Aber es geht nun =)

```
System.out.println(HexString.toHexString(packet));

        try {
            DataOutputStream wr = new DataOutputStream(this.client.getOutputStream());
            wr.writeBytes(packet);
            
            wr.flush();
        } catch (IOException ex) {
            Logger.getLogger(ClientThread.class.getName()).log(Level.SEVERE, null, ex);
        }
```


----------

