OOP IRC Client

[MWin123]

Hallo,

als mein erstes größeres Projekt möchte ich mir einen Twitch Client für Windows schreiben.

Zuerst möchte ich mal nur den Chat implementieren.
Den Twitch Chat gibt es über ein IRC Interface.
https://github.com/justintv/Twitch-API/blob/master/IRC.md

Bisher habe ich eine Verbindung aufgebaut und konnte auch einen Channel joinen und die gesendeten Nachrichten lesen. Jedoch ist mir nicht ganz klar, wie ich den Output vom IRC Server "analysieren" soll. Also z.B. warten bis die Verbindung hergestellt wurde oder auf private Nachrichten reagieren.

Bisher habe ich:

package chat;

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

public class Client {

    private String server;
    private int port;
    private String nick;
    private String password;
    private String channel;

    private Socket socket;
    private BufferedWriter writer;
    private BufferedReader reader;

    private final String NEWLINE = "\r\n";

    public BufferedReader getReader() {
        return reader;
    }

    public Client(String server, int port, String nick, String password) throws IOException {
        this.server = server;
        this.port = port;
        this.nick = nick;
        this.password = password;

        socket = new Socket(server, port);
        writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    }

    public void connect() throws IOException {
        writer.write("PASS " + password + NEWLINE);
        writer.write("NICK " + nick + NEWLINE);
        writer.flush();

        // Read lines from the server until it tells us we have connected.
        waitForCode("004");

        Thread listener = new Thread(() ->
        {
            IRCAdapter ircAdapter = new IRCAdapter(writer, reader);
            ircAdapter.setDaemon(true);
            ircAdapter.start();
        });
        listener.start();
    }

    public void disconnect() {

    }

    public void join(String channel) throws IOException {
        writer.write("JOIN " + channel + NEWLINE);
        writer.flush();

        waitForCode("366");
    }

    public void leave(String channel) {

    }

    public void message(String message) throws IOException {
        //TODO doesnt work
        writer.write("PRIVMSG " + channel + " :" + message + NEWLINE);
        writer.flush();
    }

    //TODO Bessere Implementierung, eventuell mit Listener
    private void waitForCode(String code) throws IOException {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);

            if (line.contains(code)) {
                return;
            }
        }
    }
}

package chat;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.Objects;

public class Helper extends Thread {
    private BufferedWriter writer;
    private BufferedReader reader;

    private final String NEWLINE = "\r\n";

    public Helper(BufferedWriter writer, BufferedReader reader) {
        this.writer = writer;
        this.reader = reader;
    }

    @Override
    public synchronized void start() {
        super.start();
        Objects.requireNonNull(writer);
        Objects.requireNonNull(reader);

        String line;
        try {
            while ((line = reader.readLine()) != null) {
                if (line.startsWith("PING ")) {
                    writer.write("PONG " + line.substring(5) + NEWLINE);
                    writer.flush();
                    System.out.println("PONG");
                }
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import chat.Client;

import java.io.IOException;

public class MainApp {

    public static void main(String[] args) throws IOException {
        Client client = new Client("irc.twitch.tv", 6667, "-entfernt-", "-entfernt-");

        client.connect();
        client.join("#-entfernt-");

        System.out.println("reached");
    }
}

Meine Probleme sind: Implementierung von Listenern, Threads

Ich habe mir schon die Klassen für Listener und Events geschrieben, jedoch weiß ich nicht, wo ich die hinpacken soll.

package chat;

import java.util.EventListener;

public interface Listener extends EventListener {

    void onEvent(Event event);
}

package chat;

import java.util.EventObject;

public abstract class Event extends EventObject {

    private Client client;

    public Event(Object source) {
        super(source);
        this.client = (Client) source;
    }

    public Client getClient() {
        return client;
    }
}

package chat;

public class ConnectEvent extends Event {

    public ConnectEvent(Object source) {
        super(source);
    }
}

Bisher warte ich mit der Methode waitForCode(String code) bis eine Verbindung herstellt wurde. Die Methode blockiert solange, bis der BufferedWriter eine gewissen Code vom IRC Server erhält.

Was wäre hier eine schönere Lösung?

 

[eldrior]

Um die waitForCode(...) wirst du wohl kaum rumkommen, allerdings könntest du diese in einen zusätzlichen Thread auslagern, dann wird nur dieser blockiert. Die Benachrichtigung könntest du dann entweder lösen, indem du dem Thread das zu benachrichtigende Objekt übergibst, oder du machst das schön

 

[MWin123]

oder du machst das schön

Hallo,
ich habe die beiden Bände der Insel bei mir zu Hause stehen und habe die Kapitel zu Threads und Design-Pattern schon gelesen.

Nur weiß ich nicht, wie ich die Listener hier umsetzen soll.

Soll ich den BufferReader, der die Nachrichten vom Server empfängt, in einem Thread auslagern, der jede Line analysiert und bei einem Treffer ein Event auslöst?

 

[eldrior]

Das wäre ja in sofern gut, als dass bei vielen Benachrichtigungen die Analysen auf verschiedene Threads verteilt werden, also vom Ding her ne gute Möglichkeit.
Alternativ kannst du auch mit jeder Nachricht ein Objekt benachrichtigen, das den Spaß dann analysiert und dann weiter gibt, aber das wäre keine so schöne Lösung.