Threads Thread für einen Client

[Zel2491]

Hallo
Ich hab mal eine Frage zum Thread bei einem Client für ein netwerkfähiges Chatprogramm (was Client ja schon sagt..^^)

Ich bin mir nicht ganz sicher, wie ich meinen Client in einen Thread packe, damit der immer weiter läuft und nicht nur einmal connected und dann aufhört zu arbeiten, sondern, dass ich auch noch Nachrichten versenden kann etc... (Ich glaube, ihr wisst schon was ich meine^^, hoffe ich jedenfalls )

package network;

import gui.UserInterfaceClient;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

import javax.swing.JOptionPane;

public class Client {

    private Socket server;

    private BufferedReader in;

    private OutputStreamWriter out;

    private String ip;

    private UserInterfaceClient UIC;

    public Client(String ip, UserInterfaceClient UIC) {
        this.ip = ip;
        this.UIC = UIC;

        try {

            server = new Socket(this.ip, 2000);
            in =
                new BufferedReader(new InputStreamReader(
                    server.getInputStream()));

            out = new OutputStreamWriter(server.getOutputStream());

            out.write(UIC.getIn());
            out.flush();

            JOptionPane.showMessageDialog(null, "Verbindung hergestellt");

        } catch (UnknownHostException exc) {

            JOptionPane.showMessageDialog(null,
                "Verbindung konnte nicht hergestellt werden!");
            exc.printStackTrace();

        } catch (IOException exc) {

            exc.printStackTrace();

        }

    }

}

Muss ich dann in meiner Main-Methode, oder wo immer ich das dann auch aufrufe, eine Instanz meine Klasse erstellen, z.B.

 Client client = new Client()

und das dann in einen Thread packen? Bin mir da aber nicht ganz sicher und wollte mir deshalb mal einen Rat holen

Gruß Zel

 

[Michael...]

Muss ich dann in meiner Main-Methode, oder wo immer ich das dann auch aufrufe, eine Instanz meine Klasse erstellen, z.B.

 Client client = new Client()

und das dann in einen Thread packen?

Nein, zunächst einmal musst Du das Lesen vom InputStream in eine Schleife und die in einen separaten Thread packen, damit Du zum einen wiederholt Nachrichten vom Server lesen kannst(Schleife) und zum anderen gleichzeitig Nachrichten empfangen (dafür der Thread) und senden kannst.

 

[irgendjemand]

ganz grob

server

ServerSocket serverSocket=new ServerSocket(12345);
while(RUN)
{
	Socket socket=serverSocket.accept();
	(new ClientThread(this, socket)).start();
}

client *erbt von Thread*

Server server=null;
Socket socket=null;
public ClientThread(Server server, Socket socket)
{
	this.server=server;
	this.socket=socket;
}
public void run()
{
	//streams vom socket besorgen und damit arbeiten
	//reading sieht dann in etwa so aus
	String line="";
	while(RUN)
	{
		line=bufferedReader.readLine();
		if(line==null)
		{
			RUN=false;
			continue;
		}
		if(line.equals(""))
		{
			continue;
		}
		//alle weiteren IF abfragen ...
	}
}

das ist jetzt so mal das ganz grobe schema wie ich es verwende

 

[Zel2491]

Sorry, dass ich mich erst nach 2 Tagen melde...

Schon einmal vielen Dank für die Antworten Ich begreife jetzt schon besser was ich machen muss - auch wenn ich es noch nicht geschafft habe.


Mein Inputstreamreader hab ich erstmal außen vor gelassen, da ich erst einmal das Senden von Nachrichten hinbekommen wollte - daher mach ich da auch erstmal weiter^^

Bleibt mir immer noch das Problem mit dem Thread...

Also in meinem Konstruktor mache ich nicht wirklich viel, aber in der run()-Methode mache ich dann alles? Meine sieht (vorerst) so aus:

public void run() {

        try {

            server = new Socket(this.ip, 2000);
            in =
                new BufferedReader(new InputStreamReader(
                    server.getInputStream()));

            out = new OutputStreamWriter(server.getOutputStream());

            JOptionPane.showMessageDialog(null, "Verbindung hergestellt");

            while (true) {
                out.write(uic.getIn());
                out.flush();
            }

        } catch (UnknownHostException exc) {

            JOptionPane.showMessageDialog(null,
                "Verbindung konnte nicht hergestellt werden! -"
                    + " Das Programm wird beendet.");
            System.exit(0);

            exc.printStackTrace();

        } catch (IOException exc) {

            JOptionPane.showMessageDialog(null,
                "Verbindung konnte nicht hergestellt werden! -"
                    + " Das Programm wird beendet.");
            System.exit(0);

            exc.printStackTrace();

        }

    }

Falls das so richtig ist, bin ich mir noch nicht sicher, wie ich daraus jetzt einen Thread mache...

 Client client = new Client();
Thread thread = new Thread(client);

ist nicht richtig, oder?

 

[Michael...]

Mein Inputstreamreader hab ich erstmal außen vor gelassen, da ich erst einmal das Senden von Nachrichten hinbekommen wollte - daher mach ich da auch erstmal weiter^^

Bleibt mir immer noch das Problem mit dem Thread...

Wenn Du erst einmal ausschließlich Senden willst, benötigst Du keinen Threads, ausser bei Dir laufen ServerSocket und ClientSocket in der selben "Applikation".

Falls das so richtig ist, bin ich mir noch nicht sicher, wie ich daraus jetzt einen Thread mache...

 Client client = new Client();
Thread thread = new Thread(client);

ist nicht richtig, oder?

Falsch ist es erst einmal nicht. Allerdings feuerst Du in einer Endlosschleife den Wert aus

uic.getIn()

an den Server und das soll - sofern der Aufruf nicht blockierend wirkt - vermutlich nicht so sein.

Vielleicht noch eine Erläuterung zum besseren Verständnis: Du musst nicht den "Client" in einem Thread laufen lassen. Sondern die einzelnen Funktionen des Clients müssen in verschiedenen Threads laufen. Das Lesen vom Inputstream und das Senden innerhalb des Clients müssen in einem jeweils unabhängigen Thread laufen, damit der Client während dem Warten auf neue Nachrichten (z.B. ist readLine blockierend) weiterhin senden kann.

Hier mal ein schon etwas komplexeres Beispiel, wobei hier Server und Client zur Demo innerhalb einer Applikation laufen:
http://www.java-forum.org/java-basics-anfaenger-themen/119815-variable.html#post773114

 

[Zel2491]

Okay...

in Threads bin ich jetzt nicht so bewandert... ich hab jetzt mal den BufferedReader mit einbezogen... jetzt hab ich in meiner run()-Methode ja den Reader und den Writer...wie kann ich daraus jetzt zwei von einander unabhängige Threads machen?

 

[Michael...]

...wie kann ich daraus jetzt zwei von einander unabhängige Threads machen?

Prinzipiell so wie in dem verlinkten Beispiel.
Verkürzt in etwa so:

	class Client {
		private PrintWriter writer;
		private BufferedReader reader;		

		public Client() {
			try {
				Socket socket = new Socket("ip", 2000);
				writer = new PrintWriter(socket.getOutputStream());
				reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				//Verlagern des Lesen in einen separaten Thread
				new Thread(new Runnable() {
					public void run() {
						String line;
						try {
							while((line=reader.readLine())!=null) {
								System.out.println("Empfangen: " + line);
							}
						} catch (IOException e) {
							e.printStackTrace();
						}
					}
				}).start(); //Starten eines Threads über die start Methode

			} catch (UnknownHostException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		public void sendMessage(String msg) {
			if (writer != null) {
				writer.println(msg);
				writer.flush();
			}
		}
	}

 

[Zel2491]

Okay...soweit hat das bei mir geklappt

Meine Client-Klasse sieht soweit ganz gut aus Vielen Dank für die Hilfe


Ich hab dazu jetzt noch eine andere Frage... Ich habe jetzt die Methode, wo er den Text halt herkriegt

public void sendMessage() {

        try {
            if (out != null) {
                out.write(uic.getIn());
                out.flush();
            }
        } catch (IOException exc) {
            exc.printStackTrace();
        }

    }

Und die Methode will ich jetzt in einer anderen Klasse aufrufen...
Also erzeuge ich eine Instanz der Klasse Client...
nur bin ich mir da nicht ganz sicher:

private Client client;
//...
client.sendMessage();

übergeben muss ich ja eigentlich keinen Parameter, da ich bei meinem Writer nen Getter aufrufe, der den Text ja automatisch kriegt. Es klappt aber nicht und ich denke mal, es liegt daran, dass ich eine Instanz deklariere, aber nicht initialisiere - allerdings weiß ich nicht, wie ich das Objekt richtig initialisieren soll...

 

[Michael...]

so wie Du es jetzt hast, hättest Du eine beidseitige direkte Assoziation. Das

uic.getIn()

würde ich aus dem Client herauslassen und sendMessage(String) belassen. So kann man den Client für beliebige Anwendungen verwenden.
Prinzipiell könntest Du eine Klasse (evtl. einen Listener) erstellen, welche ein/das uic Objekt und ein/das Client Objekt erstellt/kennt und so den Informationsfluss von uic zu Client steuern kann.
Wenn man es einfacher halten will, kann das uic auch direkt den Client erstellen bzw. man könnte diesem eine Referenz auf ein bereits erzeugtes Client Objekt übergeben und hätte so vollen Zugriff.

 

[Zel2491]

Aaaaaalso:

meine Client-Klasse sieht jetzt folgendermaßen aus:

package network;

import gui.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

import javax.swing.JOptionPane;

public class Client extends Thread {

    private Socket server;

    private BufferedReader in;

    private OutputStreamWriter out;

    private String ip;

    private StartingFrame sf;

    private boolean run;

    public Client(String ip, StartingFrame sf) {
        this.ip = ip;
        this.sf = sf;

        try {

            server = new Socket(this.ip, 2111);
            in =
                new BufferedReader(new InputStreamReader(
                    server.getInputStream()));

            out = new OutputStreamWriter(server.getOutputStream());
            out.write(this.sf.getUsertxt());

            JOptionPane.showMessageDialog(null, "Verbindung hergestellt");

        } catch (UnknownHostException exc) {

            JOptionPane.showMessageDialog(null,
                "Verbindung konnte nicht hergestellt werden! -"
                    + " Das Programm wird beendet.");
            System.exit(0);

            exc.printStackTrace();

        } catch (IOException exc) {

            JOptionPane.showMessageDialog(null,
                "Verbindung konnte nicht hergestellt werden! -"
                    + " Das Programm wird beendet.");
            System.exit(0);

            exc.printStackTrace();

        }

        new Thread(new Runnable() {

            public void run() {
                String line = "";
                run = true;

                while (run) {

                    try {

                        line = in.readLine();

                        if (line == null) {

                            run = false;
                            continue;

                        }
                        if (line.equals("")) {
                            continue;
                        }

                    } catch (IOException exc) {

                        exc.printStackTrace();

                    }
                }

            }
        }).start();
    }

    public void sendMessage(String msg) {

        try {
            if (out != null) {
                out.write(msg);
                out.flush();
            }
        } catch (IOException exc) {
            exc.printStackTrace();
        }

    }
}

bei [java=27]
public Client(String ip, StartingFrame sf) {
// ...
}
[/code]

übergebe ich aus meiner Klasse Starting-Frame ein Objekt, damit ich, beim connecten zum Server, dem Server den Nicknamen direkt übergeben kann:

[java=39]
out.write(this.sf.getUsertxt());
[/code]

bin mir allerdings nicht so sicher, ob das geht, weil er dann eine NPE wirft...bin mir nicht sicher, wie ich das sonst machen soll... Ich pack hier nochmal meine Klasse StartingFrame rein, falls sich das wer antuen möchte...

:

package gui;

import network.*;

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class StartingFrame extends JFrame {

    private static final long serialVersionUID = -687330130050065776L;

    private JLabel username = new JLabel("Enter Nickname:");

    private JTextField usertxt = new JTextField(10);

    private JLabel ipAdress = new JLabel("Enter IP:");

    private JTextField ipAdresstxt = new JTextField(10);

    private JButton accept = new JButton("OK");

    private JPanel center = new JPanel();

    private JPanel south = new JPanel();

    private boolean show;

    private Client client;

    private UserInterfaceClient uic;

    private StartingFrame sf;

    public StartingFrame() {

        super("Cool Version 1.0 Starting Frame");
        actionHandler();

        this.setLayout(new BorderLayout());
        this.setSize(200, 200);
        this.setLocationRelativeTo(null);
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

        center.setLayout(new GridLayout(2, 2));

        center.add(username);
        center.add(usertxt);
        center.add(ipAdress);
        center.add(ipAdresstxt);

        south.add(accept);

        this.add(center);
        this.add(BorderLayout.SOUTH, south);

        this.pack();
        show = true;
        this.setVisible(show);
    }

    private void actionHandler() {

        accept.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent evt) {
                show = false;
                setVisible(show);

                if (!usertxt.getText().isEmpty()
                    && !ipAdresstxt.getText().isEmpty()) {
                    uic =
                        new UserInterfaceClient(usertxt.getText(), ipAdresstxt
                            .getText());
                    uic.setVisible(true);

                    client = new Client(ipAdresstxt.getText(), sf);

                    Thread clientThread = new Thread(client);
                    clientThread.start();

                } else {
                    JOptionPane.showMessageDialog(null, "Ungültige Eingabe!");
                }

            }
        });

        usertxt.addKeyListener(new MyKeyListener());
        ipAdresstxt.addKeyListener(new MyKeyListener());

    }

    public String getUsertxt() {
        return usertxt.getText();
    }

    public String getIpAdresstxt() {
        return ipAdresstxt.getText();
    }

    class MyKeyListener implements KeyListener {

        public void keyPressed(KeyEvent e) {
            int key = e.getKeyCode();

            if (key == KeyEvent.VK_ENTER) {
                if (!usertxt.getText().isEmpty()
                    && !ipAdresstxt.getText().isEmpty()) {
                    show = false;
                    setVisible(show);
                    uic =
                        new UserInterfaceClient(usertxt.getText(),
                            ipAdresstxt.getText());
                    uic.setVisible(true);

                    client = new Client(ipAdresstxt.getText(), sf);

                    Thread clientThread = new Thread(client);
                    clientThread.start();

                } else {
                    JOptionPane.showMessageDialog(null, "Ungültige Eingabe!");
                }
            }

        }

        public void keyReleased(KeyEvent e) {

        }

        public void keyTyped(KeyEvent e) {

        }

    }

}

Und in meiner UserInterfaceClient-Klasse habe ich halt das Problem, dass ich meine Methode aus der Client-Klasse aufrufen will

public void sendMessage(String msg) {

        try {
            if (out != null) {
                out.write(msg);
                out.flush();
            }
        } catch (IOException exc) {
            exc.printStackTrace();
        }

    }

aaaalso muss ich ja in der betreffenden Klasse eine Instanz erzeugen, damit ich auf die Methode zugreifen kann...

das habe ich auch getan, allerdings bin ich mir recht sicher, dass das so nicht möglich ist...weil es halt nicht geht^^

private Client client;

ich initialisiere meine Variable auch nicht... aber

client = new Client();

macht irgendwie wenig Sinn hab ich den Eindruck...

naja, dann beim Aufruf:

client.sendMessage(in.getText());

wirft er mir halt wieder eine NPE, halt weil ich client nicht initialisiere...wie ich ja schon gesagt hab... Nur hab ich dafür einfach noch keine Lösung...komm da irgendwie nicht drauf, wie ich das richtig hinkriege...

Wenn man es einfacher halten will, kann das uic auch direkt den Client erstellen bzw. man könnte diesem eine Referenz auf ein bereits erzeugtes Client Objekt übergeben und hätte so vollen Zugriff.

An sich... emm, ich gebs zu: ich versteh es nicht so recht...

Falls sich wer den langen Text angetan hat und eine Idee hat... Immer raus damit^^ Ich bin weiter am probieren - falls ich ne Lösung kriege, poste ich sie hier natürlich auch...bin da aber eher pessimistisch gestimmt im Moment...Naja, vllt sieht es morgen schon besser aus

So long,

Zel