Socket Exception Connection reset

[KingOfExceptions]

Hallo Community,

ich muss euch leider wieder auf die Nerven gehen. Dieses Mal liegt es am folgenden Programm:

Server:

import java.io.*;
import java.net.*;


public class BerichtDatenbankServer 
{
	PrintWriter writer;
	
	BufferedReader reader;
	Socket sock;
	
	public static void main (String[] args)
	{
		System.out.println("start");
		new BerichtDatenbankServer().los();
	}
		
	
	public void los()
	{
		try
		{
			ServerSocket serverSock=new ServerSocket(12345);
			
			while(true)
			{
				Socket clientSocket=serverSock.accept();
				InputStreamReader r=new InputStreamReader(clientSocket.getInputStream());
				writer=new PrintWriter(clientSocket.getOutputStream());
				
				reader=new BufferedReader(r);
			
				System.out.println("habe eine Verbindung");
				lesen();
			}
		}
		catch(Exception ex){ex.printStackTrace();}
	}
		
	public void lesen()
	{
		String nachricht;
		
		try 
		{
			while((nachricht=reader.readLine())!=null)  //<-------------- FEHLER IST HIER
			{
				System.out.println("gelesen:"+nachricht);
				antwortenDassEsAngekommenIst(nachricht);
			}
		} 
		catch (IOException e) {e.printStackTrace();}
	}
	
	public void antwortenDassEsAngekommenIst(String nachricht)
	{			
		writer.print("sent");
		System.out.println("sent");
		abspeichern(nachricht);
	}
		
	public void abspeichern(String nachricht)
	{
		try
		{
			PrintWriter wr=new PrintWriter(new FileWriter("Speicherung"));				
			wr.print(nachricht);
			wr.close();
			System.out.println("SFSDSFSDF");
		}
		catch(Exception ex){ex.printStackTrace();}
	}
}

Client(ohne GUI):

class BerichtDatenbankClientHochladen
{
	String s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13,s14,s15,s16,s17,s18,s19,s20,s21,s22,s23,s24,s25,s26,s27,s28;
	JTextField field0,field1,field2,field3,field4,field5,field6,field7,field8,field9,field10,field11,field12,field13,field14,field15,field16,
	field17,field18,field19,field20,field21,field22,field23,field24,field25,field26,field27,field28;
	String msg;
	
	PrintWriter writer;
	InputStreamReader income;
	BufferedReader reader;
	Socket sock;
	

	
	public static void main(String[]args)
	{
		new BerichtDatenbankClientHochladen();
	}
	
	class Absender implements ActionListener 
	{
		public void actionPerformed(ActionEvent e) 
		{
			getContent();
			verbindungAufbauen();
			msg=s0+"/"+s1+"/"+s2+"/"+s3+"/"+s4+"/"+s5+"/"+s6+"/"+s7+"/"+s8+"/"+s9+"/"+s10+"/"+s11+"/"+s12+"/"+s13+"/"+s14+"/"+s15+"/"+s16+"/"+s17+"/"+s18+"/"+s19+"/"+s20+"/"+s21+"/"+s22+"/"+s23+"/"+s24+"/"+s25+"/"+s26+"/"+s27+"/"+s28+".";
			writer.print(msg);
			System.out.println("gesendet");
		}
	}
	
	public void verbindungAufbauen() 
	{
		try
		{
			sock=new Socket("localhost",12345);
			writer=new PrintWriter(sock.getOutputStream());
			income=new InputStreamReader(sock.getInputStream());
			reader=new BufferedReader(income);
			Thread threadPing=new Thread(new Threadder());
			threadPing.start();
		}
		catch(Exception ex){ex.printStackTrace();}
			
	}
	
	class Threadder implements Runnable         //PING
	{
		public void run()
		{
			while(true)
			{
				writer.print("ping");
				
				try
				{
					if(reader.readLine().equals("sent"))
					{
						JOptionPane.showMessageDialog(null, "Erfolgreich hochgeladen");
					}
					else if(!reader.readLine().equals("ping"))
					{
						JOptionPane.showMessageDialog(null, "Die Verbindung ist verloren gegangen.");
					}
				}
				catch(Exception ex){ex.printStackTrace();}
			}
		}

	}
}

Dabei kommt diese Fehlermeldung:

java.net.SocketException: Connection reset
	at java.net.SocketInputStream.read(Unknown Source)
	at sun.nio.cs.StreamDecoder.readBytes(Unknown Source)
	at sun.nio.cs.StreamDecoder.implRead(Unknown Source)
	at sun.nio.cs.StreamDecoder.read(Unknown Source)
	at java.io.InputStreamReader.read(Unknown Source)
	at java.io.BufferedReader.fill(Unknown Source)
	at java.io.BufferedReader.readLine(Unknown Source)
	at java.io.BufferedReader.readLine(Unknown Source)
	at BerichtDatenbankServer.lesen(BerichtDatenbankServer.java:46)
	at BerichtDatenbankServer.los(BerichtDatenbankServer.java:34)
	at BerichtDatenbankServer.main(BerichtDatenbankServer.java:15)

Ich habe auch schon schön brav die SuFu genutzt(Google auch) aber leide keine Fehlerbehebungen gefunden.

[EDIT]Wie kann ich diese ausblenden? Was hat sie zu bedeuten und wer ist der Auslöser für diese Exception?[/EDIT]

 

[...ButAlive]

Mit Fragen kannst du uns gerne auf die "Nerven" gehen. Ich sehe leider nur keine. Was erwartest du, was passiert?

 

[KingOfExceptions]

Mit Fragen kannst du uns gerne auf die "Nerven" gehen. Ich sehe leider nur keine. Was erwartest du, was passiert?

...dass keine Fehlermeldung mehr kommt ;(

 

[...ButAlive]

Jeder "Threader" sollte seine eigenen Instanzen socket und In/Output haben. Im übrigen macht man das eher auf dem Server so als auf dem Client. Wenn du das geändert hast, solltest du noch hinter

writer.print("Ping");

noch ein

writer.flush();

machen.

 

[KingOfExceptions]

Jeder "Threader" sollte seine eigenen Instanzen socket und In/Output haben. Im übrigen macht man das eher auf dem Server so als auf dem Client.

Was meinst du? Deine Aussage verstehe ich leider nicht.... ???:L Bin noch neu auf dem Gebiet der Netzwerkprogrammierung... :rtfm:

 

[...ButAlive]

Ich habe mal ein einfaches Beispiel für einen Server und einen Client geschrieben. Ich hoffe dass ich genug kommentiert habe. Vielleicht trägt es ja zu deinem Verständnis bei. Falls nicht einfach nachfragen

package org.javaforum.simpleecho;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


//Der Server
public class SimpleEchoServer {

	public static void main(String[] args) throws Exception {
		
		//Binde den Server an den Port 1024
		ServerSocket server = new ServerSocket(1024);

		//Vereinfacht die Threadverwaltung, dadurch können sich nur 2 Clients
		//gleichzeitig verbinden
		ExecutorService exectutor = Executors.newFixedThreadPool(2);
		
		//Der Server arbeitet bis er von "abgeschossen wird"
		while (true) {
			//accept wartet so lange bis sich ein Client verbindet
			Socket socket = server.accept();
			
			//Wenn ein Client da ist (socket) baue einen neuen "Worker" auf
			//Dieser übernimmt die Kommunikation mit dem einem Client
			DatenBankServerWorker worker = new DatenBankServerWorker(socket);
			
			//Execute startet einen neuen Thread
			//aber nur dann, wenn nicht 2 Client gerade schon aktiv sind
			//ansonsten wartet execute
			//man könnte hier mit einem Parameter angeben wielange gewartet werden soll
			//Danach kommt ein Timeout, den kennt man ja aus dem Internet
			exectutor.execute(worker);
		}
	}

	private static class DatenBankServerWorker implements Runnable {
		//Jeder Worker hat seine eigenen Instanzen von reader, writer und socket		
		private final BufferedReader reader;
		private final PrintWriter writer;
		private final Socket socket;

		public DatenBankServerWorker(Socket socket) throws IOException {
			
			//Die entsprechenden Dinge füllen
			this.socket = socket;
			reader = new BufferedReader(new InputStreamReader(
					socket.getInputStream()));
			writer = new PrintWriter(socket.getOutputStream());
		}

		@Override
		public void run() {

			String line = null;

			try {
				//Lese die Eingabe vom Client
				while ((line = reader.readLine()) != null) {

					//Wenn der Client "end" schickt, schicke "Bis bald" zurück
					//und verlasse die Schleife
					if("end".equals(line)){
						System.out.println("Client mag nicht mehr");
						writer.write("Bis bald");

						//"Spühlen" nicht vergessen, sonst erreicht den Client die Antwort nicht
						//da der String in irgendwelchen Buffern feststeckt.
						writer.flush();
						break;
					}
					//Sonst schicke das was der Client geschickt hat zurück
					//und hänge "verstanden" dran
					else{
						writer.println(line+" verstanden");
						
						//"Spühlen" nicht vergessen, sonst erreicht den Client die Antwort nicht
						//da der String in irgendwelchen Buffern feststeckt.
						writer.flush();
					}
				}
			} catch (IOException e) {
				//Wenn eine IOException auftritt reichen wir sie der Einfachkeit halber
				//weiter nach oben, da ich hier kein sauberes Exception-Handling gemacht habe
				//Wird der Server geschlossen.
				throw new RuntimeException(e);
			}finally{
				try {
					//Hier im finally-Block sollte man die Sachen zumachen
					reader.close();
					writer.close();
					socket.close();
				} catch (IOException e) {
					//Hier kann man kaum mehr was machen
				}
			}

		}
	}
}

package  org.javaforum.simpleecho;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

//Der Client
public class SimpleEchoClient {

	public static void main(String[] args) throws Exception {
		
		//Socket zu localhost auf port 1024 öffnen
		Socket socket = new Socket("localhost", 1024);

		//Buffered Reader aufbauen mit inputStream vom Socket
		BufferedReader in = new BufferedReader(new InputStreamReader(
				socket.getInputStream()));

		//Printwriter aufmachen für outputStream vom Socket
		PrintWriter out = new PrintWriter(socket.getOutputStream());

		//Scanner für die Eingabe
		Scanner scanner = new Scanner(System.in);

		//Solange der Socket nicht geschlossen ist
		//lese Eingabe von der Console
		while (!socket.isClosed()) {
			String message = scanner.nextLine();
			out.println(message);
			//"Spühlen" nicht vergessen da der String sonst in einem Buffer hängt
			//und nie den Server erreicht
			out.flush();
			
			//Antwort vom Server lesen
			String antwort = in.readLine();

			//Wenn Server "Bis bald" antwortet dann schließe den Socket
			//denn das kommt dann wenn du "end" geschickt hast
			//Das ist so zu sagen unter Protokoll
			if ("Bis bald".equals(antwort)) {
				socket.close();
			}
			
			//Gib die Antwort vom Server aus
			System.out.println(antwort);
		}
	}
}

 

[KingOfExceptions]

Ich gucke mir das mal lieber morgen an.... Aber vielen dank schonmal ! Nochmal konkret zu meinem Server: kannst du etwas finden, von dem du der Meinung bist, dass es die exception auslöst? Oder ist mein Code einfach ein viel zu großes Chaos ? Soweit ich das sehe habe ich ja alle Streams offen, damit die einkommenden Sachen gelesen werden können oder nicht?!

 

[...ButAlive]

Ich habe eine Vermutung, aber mehr nicht. Der Teil im Client, der eigentlich mit dem Server kommuniziert in einem anderen Thread abläuft, als der Teil der die Verbindung aufbaut, könnte es zu visibility-Problemen kommen. Evt. hilft schon ein volatile vor allen Feldern, aber das wäre wirklich hässlich. Daher meinte ich auch, dass jeder Thread seine eigenen Reader/Writer instantiieren sollte. Das sollte zumindest das Problem lösen, dass aus Server-Sicht die Connection geschlossen wird.

Damit beim Server etwas ankommt musst du auf jeden Fall ein flush(); nach dem Schreiben aufrufen.

 

[KingOfExceptions]

ich habe das ganze mal ein bisschen abgeändert....

server:

	public void los()
	{
		try
		{
			ServerSocket serverSock=new ServerSocket(12345);
			
			while(true)
			{
				Socket clientSocket=serverSock.accept();
				InputStreamReader r=new InputStreamReader(clientSocket.getInputStream());
				writer=new PrintWriter(clientSocket.getOutputStream());
				
				reader=new BufferedReader(r);
			
				System.out.println("habe eine Verbindung");
				String nachricht;
				
				try 
				{
					while((nachricht=reader.readLine())!=null)
					{
						System.out.println("gelesen:"+nachricht);
						antwortenDassEsAngekommenIst(nachricht);
					}
				} 
				catch (IOException e) {e.printStackTrace();}
			}
			
		}
		catch(Exception ex){ex.printStackTrace();}
	}

und der teil im client:

class Absender implements ActionListener 
	{
		public void actionPerformed(ActionEvent e) 
		{
			getContent();
			verbindungAufbauenUndSenden();
		}
	}
	
	
	
	public void verbindungAufbauenUndSenden() 
	{
		try
		{
			sock=new Socket("localhost",12345);
			writer=new PrintWriter(sock.getOutputStream());
			income=new InputStreamReader(sock.getInputStream());
			reader=new BufferedReader(income);
			msg=s0+"/"+s1+"/"+s2+"/"+s3+"/"+s4+"/"+s5+"/"+s6+"/"+s7+"/"+s8+"/"+s9+"/"+s10+"/"+s11+"/"+s12+"/"+s13+"/"+s14+"/"+s15+"/"+s16+"/"+s17+"/"+s18+"/"+s19+"/"+s20+"/"+s21+"/"+s22+"/"+s23+"/"+s24+"/"+s25+"/"+s26+"/"+s27+"/"+s28+".";
			writer.print(msg);
			writer.flush();
			System.out.println("gesendet");
		}
		catch(Exception ex){ex.printStackTrace();}
			
	}

somit müsste ja jetzt alles im gleichen thread laufen und da dürften auch keine visibility probleme auftauchen... aber trotzdem kommt die gleiche exception

 

[KingOfExceptions]

ok das Thema hat sich erledigt... ich hab einfach deinen Code abgeändert und dann hat es funktioniert! VIELEN DANK!!!!!

falls jemand das irgendwann auch mal brauchen sollte(man soll ja immer die Lösung posten ):

server:

import java.io.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.net.*;


public class BerichtDatenbankServer 
{
	PrintWriter writer;
	
	BufferedReader reader;
	Socket sock;
	
	public static void main (String[] args)
	{
		        
		        //Binde den Server an den Port 1024
		       ServerSocket server = null;
			try {
				server = new ServerSocket(12345);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		       
		        //Vereinfacht die Threadverwaltung, dadurch können sich nur 2 Clients
		        //gleichzeitig verbinden
		        ExecutorService exectutor = Executors.newFixedThreadPool(2);
		        
		        //Der Server arbeitet bis er von "abgeschossen wird"
		        while (true) {
		            //accept wartet so lange bis sich ein Client verbindet
		            Socket socket = null;
					try {
						socket = server.accept();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
		            
		            //Wenn ein Client da ist (socket) baue einen neuen "Worker" auf
		            //Dieser übernimmt die Kommunikation mit dem einem Client
		            DatenBankServerWorker worker = null;
					try {
						worker = new DatenBankServerWorker(socket);
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
		            
		            //Execute startet einen neuen Thread
		            //aber nur dann, wenn nicht 2 Client gerade schon aktiv sind
		            //ansonsten wartet execute
		            //man könnte hier mit einem Parameter angeben wielange gewartet werden soll
		            //Danach kommt ein Timeout, den kennt man ja aus dem Internet
		            exectutor.execute(worker);
		        }
		    }
		 
		    private static class DatenBankServerWorker implements Runnable {
		        //Jeder Worker hat seine eigenen Instanzen von reader, writer und socket        
		        private final BufferedReader reader;
		        private final PrintWriter writer;
		        private final Socket socket;
		 
		        public DatenBankServerWorker(Socket socket) throws IOException {
		            
		            //Die entsprechenden Dinge füllen
		            this.socket = socket;
		            reader = new BufferedReader(new InputStreamReader(
		                    socket.getInputStream()));
		            writer = new PrintWriter(socket.getOutputStream());
		        }
		 
		        @Override
		        public void run() {
		 
		            String line = null;
		 
		            try 
		            {
		                //Lese die Eingabe vom Client
		                while ((line = reader.readLine()) != null) 
		                {
		 
		                    //Wenn der Client "end" schickt, schicke "Bis bald" zurück
		                    //und verlasse die Schleife
		                    
		                	if(line.contains("/"))
		                    {
		                        System.out.println("Bericht da");
		                        writer.write("sent");
		 
		                        //"Spühlen" nicht vergessen, sonst erreicht den Client die Antwort nicht
		                        //da der String in irgendwelchen Buffern feststeckt.
		                        writer.flush();
		                        break;
		                    }
		                    //Sonst schicke das was der Client geschickt hat zurück
		                    //und hänge "verstanden" dran
		                    else
		                    {
		                        writer.println(line+" ist nicht richtig");
		                        
		                        //"Spühlen" nicht vergessen, sonst erreicht den Client die Antwort nicht
		                        //da der String in irgendwelchen Buffern feststeckt.
		                        writer.flush();
		                    }
		                }
		   
		            } 
		            catch (IOException e) 
		            {
		                //Wenn eine IOException auftritt reichen wir sie der Einfachkeit halber
		                //weiter nach oben, da ich hier kein sauberes Exception-Handling gemacht habe
		                //Wird der Server geschlossen.
		                throw new RuntimeException(e);
		            }
		            finally
		            {
		                try 
		                {
		                    //Hier im finally-Block sollte man die Sachen zumachen
		                    reader.close();
		                    writer.close();
		                    socket.close();
		                } 
		                
		                catch (IOException e)
		                {
		                    //Hier kann man kaum mehr was machen
		                }
		            }
		 
		        }
		    }
		}

client(nur der teil der wichtig ist (der rest ist bei mir alles GUI und ähnliches):

	public void verbindungAufbauenUndSenden() 
	{
		try
		{
			msg=s0+"/"+s1+"/"+s2+"/"+s3+"/"+s4+"/"+s5+"/"+s6+"/"+s7+"/"+s8+"/"+s9+"/"+s10+"/"+s11+"/"+s12+"/"+s13+"/"+s14+"/"+s15+"/"+s16+"/"+s17+"/"+s18+"/"+s19+"/"+s20+"/"+s21+"/"+s22+"/"+s23+"/"+s24+"/"+s25+"/"+s26+"/"+s27+"/"+s28+".";
			new Verbinder();
			System.out.println("gesendet");
		}
		catch(Exception ex){ex.printStackTrace();}
			
	}	
	
	class Verbinder
	{
		Verbinder() throws UnknownHostException, IOException
		{
			Socket socket = new Socket("localhost", 12345);
			 
	        //Buffered Reader aufbauen mit inputStream vom Socket
	        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
	 
	        //Printwriter aufmachen für outputStream vom Socket
	        PrintWriter out = new PrintWriter(socket.getOutputStream());
	        
	        while (!socket.isClosed()) 
	        {
	            out.println(msg);
	            out.flush();
	            
	            //Antwort vom Server lesen
	            String antwort = in.readLine();
	 
	           
	            if ("sent".equals(antwort))
	            {
	                socket.close();
	                JOptionPane.showMessageDialog(null, "Erfolgreich hochgeladen");
	            }
	            
	            //Gib die Antwort vom Server aus
	            System.out.println(antwort);
	        }
		}
		
    
	}
}