[JAVA] Simpel (denk ik) Server-Client probleem

[Verwijderd]

Het zal wel weet iets heel kleins zijn maar ik breek me hier echt mn kop op, ik heb een Client en een Server klasse die connecten met elkaar en de server gaat dan non-stop wat naar de client sturen (via de outputstream). Maar op de een of andere manier krijgt de Client het niet binnen..

Dit zijn de klassen:

TestServer.java

Java:

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

public class TestServer {
    
    private ServerSocket ssock;
    private BufferedReader in;
    private BufferedWriter out;
    
    public TestServer() {
        try {
            ssock = new ServerSocket(7152);
            Socket s = ssock.accept();
            in = new BufferedReader(new InputStreamReader(s.getInputStream()));
            out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("connectie gemaakt");
        run();
    }
    
    private synchronized void run() {
        try {
            int test=1;
            for (;;) {
                wait(500);
                System.out.println("Writing #"+test);
                out.write("SENDING #"+test);
                out.flush();
                test++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        new TestServer();
    }

} // end of class

TestClient.java

Java:

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

public class TestClient {
    
    private Socket s;
    private BufferedReader in;
    private BufferedWriter out;

    public TestClient() {
        try { 
                System.out.println("Attempting to connect ..");
                makeConnection();
            } catch (Exception exc) {
                System.out.println("Connection failed .. \n");
                System.exit(0);
            }
            System.out.println("connection established");
            run();
        }
        
        private void run() {
            String s;
            try {
                System.out.println("Trying to read from input\n");
                while (true) {
                s = in.readLine();
                System.out.println("received: "+s);
                }
            } catch (IOException ioe) {
                System.out.println("Connection lost ..\n");
            }
        }
        
        private void makeConnection() throws Exception {
            s = new Socket("localhost",7152);
        in = new BufferedReader(new InputStreamReader(s.getInputStream()));
        out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        }
            
        
        public static void main(String[] args) {
           new TestClient();
        }
} // end of class   

Start uiteraard eerst de server op en dan connect de client, het connecten gaat goed maar het uitwisselen van gegevens gaat fout.. ik dacht zelf dat ik per ongeluk de in- en outputstreams had verwisseld maar dat is echt niet zo Ik flush ook netjes..

Wie helpt?

p.s. Ik weet dat de code een rotzooi is, maar dit is alleen om ff dit probleempje op te lossen.

[Verwijderd]

Ik heb niet veel zin om je code te gaan debuggen, zoeken op fouten, maar misschien ben je met deze 2 files wel iets: een klein chat-server programmatje wat ik een tijdje terug gemaakt heb:

Client.java

code:

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

public class Client
{
    public static void main(String args[]) throws UnknownHostException, IOException
    {
        Socket clientSocket = new Socket("localhost", 1234);
        
        ClientListener clientListener = new ClientListener(clientSocket);
        
        PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        String input;
        boolean stop = false;
        
        while (!stop)
        {
            input = reader.readLine();
            
            writer.println(input);
            
            if (input.equals("disconnect"))
            {
                clientListener.setEnabled(false);
                stop = true;
            }
        }
        
        clientSocket.close();
        reader.close();
        writer.close();
    }   
}

class ClientListener extends Thread
{
    private Socket m_clientSocket = null;
    private boolean m_enabled = true;
    
    public ClientListener(Socket clientSocket) throws IOException
    {
        m_clientSocket = clientSocket;
        
        this.start();
    }
    
    public void run()
    {
        BufferedReader reader = null;
        
        try
        {
            reader = new BufferedReader(new InputStreamReader(m_clientSocket.getInputStream()));
        
            while (m_enabled)
            {
                if (reader.ready())
                {
                    System.out.println("[MESSAGE] " + reader.readLine());
                }
            }
        }
        catch (IOException e)
        {
            
        }
        finally
        {
            try
            {
                reader.close(); 
            }   
            catch (IOException e)
            {
            
            }
        }
    }
    
    public void setEnabled(boolean enabled)
    {
        m_enabled = enabled;    
    }
}

Server.java

code:

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

public class Server
{
    public static void main(String args[]) throws IOException
    {
        ServerSocket serverSocket = new ServerSocket(1234);
        ClientCollector clientCollector = new ClientCollector();
        
        while (true)
        {
            Socket clientSocket = serverSocket.accept();
            
            System.out.println("[SERVER] - Client connected");
            
            ServerThread client = new ServerThread(clientSocket, clientCollector);
            
            clientCollector.addClient(client);
            
            client.start();
        }
    }   
}

class ClientCollector
{
    Vector m_clientVector = new Vector();
    
    public void addClient(ServerThread clientSocket)
    {
        m_clientVector.add(clientSocket);
        
        System.out.println("[SERVER] - Client added");
    }
    
    public void removeClient(ServerThread clientSocket)
    {
        m_clientVector.remove(clientSocket);
    }
    
    public Vector getClients()
    {
        return m_clientVector;  
    }
}

class ServerThread extends Thread
{
    Socket m_clientSocket               = null;
    ClientCollector m_clientCollector   = null;
    BufferedReader m_reader             = null;
    PrintWriter m_writer                = null;
    
    public ServerThread(Socket clientSocket, ClientCollector clientCollector) throws IOException
    {
        m_clientSocket = clientSocket;
        m_clientCollector = clientCollector;
        
        m_reader = new BufferedReader(new InputStreamReader(m_clientSocket.getInputStream()));
        m_writer = new PrintWriter(new OutputStreamWriter(m_clientSocket.getOutputStream()), true);
    }
    
    public void run()
    {
        BufferedReader reader = null;
        String input;
        boolean run = true;
        
        try
        {
            while (run)
            {
                if (m_reader.ready())
                {
                    System.out.println("[SERVER] - Ready for message");
                    
                    input = m_reader.readLine();
                    
                    if (input.equals("disconnect"))
                        run = false;
                    else
                    {
                        System.out.println("[SERVER] - Message from client (" + input + ")");
                    
                        Vector clientVector = m_clientCollector.getClients();
                        Iterator it = clientVector.iterator();
            
                        while (it.hasNext())
                        {
                            ServerThread client = (ServerThread) it.next();
        
                            client.sendMessageToClient(input);
                        
                            System.out.println("[SERVER] - Message to client (" + input + ")");
                        }
                    }
                }
            }
        }
        catch (IOException e)
        {
            
        }
        finally
        {
            try
            {
                disconnectClient();
                
                m_reader.close();
                m_writer.close();
            }
            catch (IOException e)
            {
                
            }
        }
    }
    
    public void sendMessageToClient(String message) throws IOException
    {
        m_writer.println(message);
    }
    
    public void disconnectClient() throws IOException
    {
        m_clientSocket.close();
        m_clientCollector.removeClient(this);
                
        System.out.println("[SERVER] - Client disconnected");           
    }
}

[narotic]

offtopic:
Ik zou eerst je code geschikt maken voor threads, dus of Thread extenden zoals in de code hierboven, of Runnable implementen.

[kim72]

Volgens mij is het probleem dat een readLine wacht tot ie een \n (newline character) tegenkomt en dan pas iets teruggeeft. Probeer in de server eens een \n toe te voegen aan de te verzenden text.

[narotic]

Dat zou idd wel eens het probleem kunnen zijn. Netste is daarvoor newline() methode van BufferedWriter te gebruiken.

[Verwijderd]

Ok even problemen, trouwens ik heb wel vaker client-server applicaties geschreven en ben ook op de hoogte dat deze maar 1 client kan afwerken maar dit is alleen voor het testen he.

Jaaaa dat was het.. super bedankt. Dat ik dat nou niet wist he Ik heb in het verleden altijd met DataOuputStreams gewerkt, zal wel weer anders zijn/

[ Voor 31% gewijzigd door Verwijderd op 16-10-2003 07:03 ]