Hi zusammen,

ich bin seit einigen Wochen mit ein un demselben Problem zu gange.

Vielleicht kann mir ja hier jemand weiterhelfen...

also, ich versuche eine Kommunikation zwischen 2 PC's zustande zu bringen.

Hier der Code vom Client:

import java.io.*;

import java.net.*;


public class NetTest {


	/**

	 * @param args

	 */

	public static void main(String[] args) {

		// NetTestClient


		try{

			Socket socket = new Socket("192.168.178.107",9999);

			System.out.println("Connected to "+socket.getRemoteSocketAddress());


			String str;


	        BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

	        BufferedReader rd = new BufferedReader(new InputStreamReader(socket.getInputStream()));


	        wr.write("Hello Server");

	        wr.flush();


	        while ((str = rd.readLine()) != null) {

	        	System.out.println(str);

	        }




	        rd.close();

	        socket.close();


		}catch(IOException e){

			System.out.print(e);

		}


	}


}

[/PHP]

Und hier der Code vom Server:

[PHP]import java.net.ServerSocket;
import java.net.Socket;
import java.io.*;

public class NetTest {

/**
* @param args
*/
public static void main(String[] args) {
// NetTestServer

try{
ServerSocket sSocket = new ServerSocket(9999);
Socket connection;
String str;

System.out.println("Server started at Port "+sSocket.getLocalPort());

connection = sSocket.accept();
System.out.println("Incoming connection from "+connection.getInetAddress()+" @ "+connection.getPort());

BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream()));
BufferedReader rd = new BufferedReader(new InputStreamReader(connection.getInputStream()));

while ((str = rd.readLine()) != null) {
System.out.println("Recieved: "+str);
wr.write("RCV_"+str);
wr.flush();
System.out.println("Sent: RCV_"+str);
}

rd.close();
wr.close();
connection.close();

}catch(IOException e){
System.out.print(e);
}




}

}

ich hab das mittlerweile alles nur noch als Test, weil die Verbindung gar nicht funktioniert, also das ganze drumherum fehlt.

Das Problem ist nun dass der Client scheinbar seinen Outputstream nicht flusht, oder er "schickt" den String nur, wenn der Stream geschlossen wird.

Weiss zufällig jemand rat?

Nochwas: Wenn ich den Outputstream schliesse und danach versuche den Inputstream zu lesen kriege ich eine Exception (Socket closed) muss das so sein? Wenn ja, warum?

Wäre über Hilfe echt dankbar, mir qualmt der Kopf

Ah nee, mein Fehler

Hmm, also laut Deinem Code, ist das eine blockierende Verbindung (synchrone Socket-programmierung) und keine asychrone (non-blocking).

Deshalb wartest Du falsch mit Deinen beiden readLine().

Der Client und der Server warten mit readLine() auf eine Zeile, aber weder Client noch Server senden jemals ein Zeilenende, so dass Deine while-Schleife betreten wird.

Vermute da liegt der Fehler.

Also, der Client schickt ein zeilenende, wenn ich nämlich beim Client die Schleife wegkommentiere läft er durch und der Server macht die Ausgabe und beendet dann.

hmm, Dein BufferedWriter schreibt weder CarrigeReturn noch ein LineFeed, also kein Zeilenende, der flusht nur.

Ich teste Deinen Code gleich mal in meinem Eclipse.

Hinweis:

Bitte nutze doch das New-IO der Java-API anstelle der betagten blocking-Sockets.

Also, der Client schickt ein zeilenende, wenn ich nämlich beim Client die Schleife wegkommentiere läft er durch und der Server macht die Ausgabe und beendet dann.

Du solltest Deinen Client mal debuggen und den Server in einer Console daneben offen haben.

Dann siehst Du eindeutig, dass Du bitte nicht verwechseln darfst, das im Server.readLine() auch returnt, wenn der Client-Socket geschlossen wird.

Reproduzierbar indem Du einfach die Schleife im Client auskommentierst und einen Haltepunkt setzt auf rd.close(). Wenn Du genau diese Zeile ausführst, bvekommt der Server plötzlich seine Zeile, aber nur weil durch rd.close() ein shutdownInput() gemacht wird.

Habe grade Deinen Client getestet und eine Zeile eingefügt und siehe da, es funktioniert!

wr.write("Hello Server");

wr.flush();

socket.shutdownOutput();

Ich hab Dir das mal für das New-IO package umprogrammiert. Als Grundlage (ohne Fehlerbehandlung):

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.nio.ByteBuffer;

import java.nio.channels.SocketChannel;

import java.nio.charset.Charset;


public class TestClient

{


    public static void main(String[] args)

    {

        try

        {

            Charset std = Charset.defaultCharset();

            InetSocketAddress isa = new InetSocketAddress("192.168.178.107", 9999);

            SocketChannel client = SocketChannel.open();            

            Socket socket = client.socket();

            socket.connect(isa, 1000);

            System.out.println("Connected to "+socket.getRemoteSocketAddress()); 


            client.write(std.encode("Hello Server")); 


            ByteBuffer bb = ByteBuffer.allocateDirect(8192);

            if ( client.read(bb) != -1 )

            {

                bb.flip();

                String str = std.decode(bb).toString();

                System.out.println(str); 

                bb.clear(); // unnötig, da keine while, sondern nur einmal if

            }// while read

            client.close(); 


        }

        catch(IOException e)

        {

            e.printStackTrace(System.out);

        }


    }


}

Server:

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.ServerSocket;

import java.nio.ByteBuffer;

import java.nio.channels.ServerSocketChannel;

import java.nio.channels.SocketChannel;

import java.nio.charset.Charset;


public class TestServer

{


    public static void main(String[] args)

    {

        try

        {

            Charset std = Charset.defaultCharset();

            InetSocketAddress isa = new InetSocketAddress("0.0.0.0", 9999);

            ServerSocketChannel server = ServerSocketChannel.open();

            ServerSocket socket = server.socket();

            socket.bind(isa);

            System.out.println("Server started at Port "+socket.getLocalPort()); 


            ByteBuffer bb = ByteBuffer.allocateDirect(8192);

            SocketChannel client = null;

            while ( (client = server.accept()) != null )

                try

            {               


                    System.out.println("Incoming connection from "+client.socket().getInetAddress()+" @ "+client.socket().getPort()); 


                    if ( client.read(bb) != -1 ) {


                        bb.flip();                        

                        String str = std.decode(bb).toString();

                        System.out.println("Recieved: "+str); 

                        client.write(std.encode("RCV_"+str));

                        System.out.println("Sent: RCV_"+str);

                        bb.clear();


                    }// while read

                }// try

                finally {

                    client.close();

                }// while accept 


            server.close(); 


        }

        catch(IOException e)

        { 

            e.printStackTrace(System.out); 

        }

     }


}

Wow, danke, dass du dir so viel mühe gemacht hast.

Ich werd mich direkt dranmachen zu gucken wer, wie wo und was.

1000 Dank auf jeden Fall schonmal

okay...der erste Schritt ist deke ich gemacht.

Ich hab jetzt erstmal immer

wr.write("Hello Server"+System.getProperty("line.separator"));

hinzugefügt...und es geht *beeindruckt*

Ich wollte den Socketinput/output nicht schliessen, den brauch ich später noch

Dann werd ich jetzt mal gucken, wie das mit den IO_New-Sockets geht.

Werd mich erst mal n bissl belesen was da wie wo is und überhaupt...

Aber hey, du hattest Recht

Recht zu haben ist eine Erkenntnis nach der Analyse. Und wichtig ist nur die Analyse.

Das mit der New-IO habe ich deshalb gesagt, weil:

- das von Java der zu bevorzugende Weg ist oder werden soll,

- es direkte Unterstützung für typische Probleme gibt (unterschiedliche Charsets, Pufferung) die direkt ineinandergreifen,

- der Umstieg in asynchrone (non-blocking) Socket-Programmierung mittels Semaphoren dann nicht mehr so schwer fällt.