Funktioniert (Nicht schön aber selten)

src/ChatProgramm/controller/CommandController.java

     }
     
     public void registerCommands(){
-        invoker.addCommand(view.getBtnConnect(), new CommandConnect(view));
-        invoker.addCommand(view.getTfNachricht(), new CommandSend(view));
+        CommandSend commandSend = new CommandSend(view);
+        invoker.addCommand(view.getBtnConnect(), new CommandConnect(view, commandSend));
+        invoker.addCommand(view.getTfNachricht(), commandSend);
     }
 
     /**

src/ChatProgramm/controller/Nachricht.java

     
   public Nachricht(String nachricht)
   {
-      this.nachricht = nachricht;
+      this.setNachricht(nachricht);
       //this.id = id;
   
   }
     public String getNachricht() {
         return nachricht;
     }
+
+    public void setNachricht(String nachricht) {
+        this.nachricht = nachricht;
+    }
 }

src/ChatProgramm/controller/commands/CommandConnect.java

     private JRadioButton rBtnClient;
     private JDialog dialogFenster;
     private static Logger lg = OhmLogger.getLogger();
+
+    private CommandSend commandSend;
+
+    private ChatView view;
     
-  public CommandConnect(ChatView view)
+  public CommandConnect(ChatView view, CommandInterface value)
   {
       rBtnServer = view.getBtnServer();
       rBtnClient = view.getBtnClient();
       dialogFenster = view.getjDialog1();
+
+      commandSend = (CommandSend) value;
+
+      this.view = view;
   }
 
   @Override
       if(rBtnServer.isSelected()){
           lg.info("Server ausgewählt");
           try {
-              new Server();
+             commandSend.transmitterInterface =  new Server(view);
           } catch (IOException ex) {
               lg.info("Die Verbindung zum Server ist Fehlgeschlagen");
           }
       if(rBtnClient.isSelected()){
           lg.info("Client ausgewählt");
           try {
-              new Client();
+              commandSend.transmitterInterface =  new Client(view);
           } catch (IOException ex) {
               lg.info("Die Verbindung zum Client ist Fehlgeschlagen");
 

src/ChatProgramm/controller/commands/CommandSend.java

 import ChatProgramm.model.Client;
 import ChatProgramm.model.Server;
 import ChatProgramm.model.Transmitter;
+import ChatProgramm.model.TransmitterInterface;
 import ChatProgramm.util.OhmLogger;
 import ChatProgramm.view.ChatView;
+
+import java.util.Objects;
 import java.util.logging.Logger;
 import javax.swing.JTextField;
 
     private static Logger lg = OhmLogger.getLogger();
     
     private ChatView view;
+    public TransmitterInterface transmitterInterface;
     private JTextField eingabeFeld;
     
     public Server server;
   {
       this.view = view;
       this.eingabeFeld = view.getTfNachricht();
+      transmitterInterface = null;
   }
 
   @Override
   public void execute()
   {
-      //Transmitter.send(new Nachricht(eingabeFeld.getText()));
-      lg.info("Sende Nachricht");
+      if(transmitterInterface != null && !eingabeFeld.getText().isEmpty()){
+          lg.info("Sende Nachricht");
+          transmitterInterface.send(new Nachricht(eingabeFeld.getText()));
+          eingabeFeld.setText("");
+      }
   }
 
   @Override

src/ChatProgramm/model/Client.java

  */
 package ChatProgramm.model;
 
-import ChatProgramm.controller.Nachricht;
-import java.io.BufferedReader;
+import ChatProgramm.view.ChatView;
+
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.UnsupportedEncodingException;
-import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.logging.*;
 
     private static Logger lg = Logger.getLogger("netz");
 
 
-    public Client() throws IOException {
+    public Client(ChatView view) throws IOException {
+        super(view);
         connect();
         initIO();
 
 //        s.close();
     }
 
-    /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) {
-        try {
-            new Client();
-        } catch (IOException ex) {
-            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
-        }
-    }
 
     @Override
     public void connect() throws IOException {

src/ChatProgramm/model/Server.java

 package ChatProgramm.model;
 
 import ChatProgramm.model.Transmitter;
+import ChatProgramm.view.ChatView;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 
 
 
-    public Server() throws IOException {
-        super();
+    public Server(ChatView view) throws IOException {
+        super(view);
         connect();
         initIO();
 
 //    s.close();
     }
 
-    /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) {
-        try {
-            new Server();
-        } catch (IOException ex) {
-            Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
-        }
-    }
-
 
 
 }

src/ChatProgramm/model/Transmitter.java

 package ChatProgramm.model;
 
 import ChatProgramm.controller.Nachricht;
+import ChatProgramm.controller.ReceiveAdapter;
+import ChatProgramm.view.ChatView;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.UnsupportedEncodingException;
-import java.net.ServerSocket;
 import java.net.Socket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Flow;
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.SubmissionPublisher;
  *
  * @author ahren
  */
-public abstract class Transmitter implements Runnable, Subscriber<Nachricht> {
+public abstract class Transmitter implements Runnable, Subscriber<Nachricht>, TransmitterInterface {
 
-    static final int timeout = 10000;
+    static final int timeout = 30000;
     protected static final int PORT = 35000;
     protected static final String IP = "127.0.0.1";
 
     protected PrintWriter writer;
 
     private SubmissionPublisher<Nachricht> textPublisher;
-    private Thread thd;
-    private boolean laufend;
+    private ExecutorService eService;
+    private boolean laufend = false;
+
+    private ChatView view;
+
+    private ReceiveAdapter receiveAdapter;
 
-    public Transmitter() {
+    public Transmitter(ChatView view) {
         socket = new Socket();
+        eService = null;
+        this.view = view;
+        textPublisher = new SubmissionPublisher<>();
+
+        receiveAdapter = new ReceiveAdapter(view);
+        addWertSubscription(receiveAdapter);
     }
 
     public abstract void connect() throws IOException;
             writer = new PrintWriter(osr);
             lg.info("Initialisierung abgeschlossen");
 
-            lg.info("Warte auf Nachricht");
+            start();
 
-        } catch (UnsupportedEncodingException ex) {
-            Logger.getLogger(Transmitter.class.getName()).log(Level.SEVERE, null, ex);
         } catch (IOException ex) {
             Logger.getLogger(Transmitter.class.getName()).log(Level.SEVERE, null, ex);
         }
     }
 
+    public void start(){
+        synchronized (this){
+            laufend = true;
+        }
+
+        if (eService == null){
+            eService = Executors.newSingleThreadExecutor();
+            eService.execute(this);
+        }
+
+        lg.info("Starte Chat");
+    }
+
     public void send(Nachricht nachricht) {
         lg.info("Nachricht wird gesendet");
         writer.println(nachricht.getNachricht());
         writer.flush();
 
         lg.info("Nachricht wird angezeigt");
+        lg.info(nachricht.getNachricht());
         textPublisher.submit(nachricht);
     }
 
-//    public void startServer() {
-//        laufend = true;
-//        if (thd == null) {
-//            thd = new Thread(this);
-//            thd.start();
-//        }
-//
-//        synchronized (thd) {
-//            thd.notify();
-//        }
-//
-//    }
+    public Nachricht recieve(){
+        Nachricht nachricht = new Nachricht("");
+        try {
+            String txtNachricht = reader.readLine();
+            if(!txtNachricht.isEmpty()){
+                lg.info("Nachricht erhalten");
+                nachricht.setNachricht(txtNachricht);
+                return nachricht;
+            }
+
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+
+        return nachricht;
+    }
+
 
     @Override
     public void run() {
-        try {
-            Nachricht nachricht = new Nachricht(reader.readLine());
-            textPublisher.submit(nachricht);
-        } catch (IOException ex) {
-            Logger.getLogger(Transmitter.class.getName()).log(Level.SEVERE, null, ex);
+        while (true) {
+            lg.info("running");
+            if(laufend) {
+                Nachricht eingehendeNachricht = recieve();
+
+                if(!eingehendeNachricht.getNachricht().isEmpty()){
+                    textPublisher.submit(eingehendeNachricht);
+                }
+
+            }
+            else{
+                break;
+            }
         }
     }
 

src/ChatProgramm/model/TransmitterInterface.java

+package ChatProgramm.model;
+
+import ChatProgramm.controller.Nachricht;
+
+import java.util.concurrent.Flow;
+
+public interface TransmitterInterface{
+    public void send(Nachricht nachricht);
+    public Nachricht recieve();
+}