Network

import java.awt.EventQueue;
import java.io.IOException;
import java.net.*;
import java.util.*;

public class Server {

  private ServerSocket serverSocket;

  private boolean connected;

  private int port;

  private ArrayList<Client> clients;

  private ServerReceiveClients serverReceiveClients;

  private ArrayList<ServerListener> serverListeners = new ArrayList<ServerListener>();

  public void addServerListener(ServerListener serverListener){
    serverListeners.add(serverListener);
  }

  public void addServerListener(ArrayList<ServerListener> serverListeners){
    this.serverListeners.addAll(serverListeners);
  }

  public ArrayList<Client> getClients() {
    return clients;
  }

  private void setServerReceiveClients(ServerReceiveClients receiveClients) {
    this.serverReceiveClients = receiveClients;
  }

  public ServerReceiveClients getServerReceiveClients() {
    return serverReceiveClients;
  }

  private void setClients(ArrayList<Client> clients) {
    this.clients = clients;
  }

  public ServerSocket getServerSocket() {
    return serverSocket;
  }

  private void setServerSocket(ServerSocket serverSocket) {
    this.serverSocket = serverSocket;
  }

  public int getPort() {
    return port;
  }

  private void setPort(int port) {
    this.port = port;
  }

  public boolean isConnected() {
    return connected;
  }

  private void setConnected(boolean connected) {
    this.connected = connected;
  }

  public Server(int port, ServerListener serverListener) throws IOException{
    if (serverListener != null){
      this.addServerListener(serverListener);
    }
    init(port);
  }

  public Server(int port, ArrayList<ServerListener> serverListeners) throws IOException{
    if (serverListeners != null){
      this.addServerListener(serverListeners);
    }
    init(port);
  }

  public Server(int port) throws IOException{
    init(port);
  }

  private void init(int port) throws IOException{
    setConnected(false);
    setPort(port);
    setClients(new ArrayList<Client>());
    setServerSocket(new ServerSocket(getPort()));
    serverConnected();
    ServerReceiveClients serverReceiveClients = new ServerReceiveClients(this);
    setServerReceiveClients(serverReceiveClients);
    getServerReceiveClients().start();
    Runtime.getRuntime().addShutdownHook(new ServerShutdownHook(this));
  }

  public void stop() throws IOException {
    stop(true);
  }

  void stop(final boolean volitional) throws IOException {
    if (!isConnected()){return;}
    setConnected(false);
    for (Client c : getClients()){
      c.stop(true);
    }
    getClients().clear();
    getServerSocket().close();
    EventQueue.invokeLater(new Runnable() {
      public void run() {
        try {
          for (final ServerListener s : serverListeners){
            s.serverStopped(volitional);
          }
        }
        catch (Exception e) {
          e.printStackTrace();
        }
      }
    });

  }

  public void broadcast(String content) throws IOException, NotConnectedException{
    broadcast(content.getBytes());
  }

  public void broadcast(byte[] content) throws IOException, NotConnectedException{
    for (Client c : getClients()){
      c.write(content);
    }
  }

  void serverConnected(){
    setConnected(true);
    EventQueue.invokeLater(new Runnable() {
      public void run() {
        try {
          for (final ServerListener s : serverListeners){
            s.serverConnected();
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    });
  }

  void clientConnected(Client c){
    getClients().add(c);
    for (ServerListener s : serverListeners){
      s.clientConnected(c);
    }
  }

    void clientStopped(Client c, boolean volitional){
      if (isConnected()){
        getClients().remove(c);
        for (ServerListener s : serverListeners){
          s.clientStopped(c, volitional);
        }
      }
  }

    void clientNewMessage(Client c,byte[] content){
      for (ServerListener s : serverListeners){
      s.clientNewMessage(c, content);
    }
    }

}

class ServerReceiveClients extends Thread {

  private Server server;
  public Server getServer() {
    return server;
  }
  public void setServer(Server server) {
    this.server = server;
  }

  public ServerReceiveClients(Server server){
    setServer(server);
  }

  @Override
  public void run() {
    while (getServer().isConnected()){
      try{
        Socket newSocket = getServer().getServerSocket().accept();
        final Client newClient = new Client();
        newClient.addClientListener(new ClientListener(){
          @Override
          public void connected() {
            getServer().clientConnected(newClient);
          }
          @Override
          public void stopped(boolean volitional) {
            getServer().clientStopped(newClient, volitional);
          }
          @Override
          public void newMessage(byte[] content) {
            getServer().clientNewMessage(newClient,content);
          }
        });
        newClient.init(newSocket);
      }
      catch (Exception se){
        if (!getServer().isConnected()){return;}
        try {
          getServer().stop(false);
        } catch (IOException e) {e.printStackTrace();}
      }
    }
  }
}

class ServerShutdownHook extends Thread{
  private Server server;
  public Server getServer() {
    return server;
  }
  public void setServer(Server server) {
    this.server = server;
  }

  public ServerShutdownHook(Server server){
    setServer(server);
  }
  public void run() {
    try {
      getServer().stop(false);
    } catch (Exception e) {}
  }
}






public interface ServerListener{
    void serverConnected();
    void serverStopped(boolean volitional);

    void clientConnected(Client c);
    void clientStopped(Client c, boolean volitional);
    void clientNewMessage(Client c, byte[] content);
}









import java.net.*;
import java.util.*;
import java.awt.EventQueue;
import java.io.*;

public class Client {

    private Socket socket;
    private OutputStream outputStream;
    private InputStream inputStream;
    private ClientReceiveMessages clientReceiveMessages;

    private ArrayList<ClientListener> clientListeners = new ArrayList<ClientListener>();

    private boolean connected;

    public void addClientListener(ClientListener clientListener){
        clientListeners.add(clientListener);
    }

    public void addClientListener(ArrayList<ClientListener> clientListener){
        clientListeners.addAll(clientListener);
    }

    public boolean isConnected() {
        return connected;
    }

    private void setConnected(boolean connected) {
        this.connected = connected;
    }

    public ClientReceiveMessages getClientReceiveMessages() {
        return clientReceiveMessages;
    }
    private void setClientReceiveMessages(
            ClientReceiveMessages clientReceiveMessages) {
        this.clientReceiveMessages = clientReceiveMessages;
    }

    public Socket getSocket() {
        return socket;
    }
    private void setSocket(Socket socket) {
        this.socket = socket;
    }
    private OutputStream getOutputStream() {
        return outputStream;
    }
    private void setOutputStream(OutputStream outputStream) {
        this.outputStream = outputStream;
    }
    InputStream getInputStream() {
        return inputStream;
    }
    private void setInputStream(DataInputStream inputStream) {
        this.inputStream = inputStream;
    }

    void setInputStream(InputStream inputStream) {
        this.inputStream = inputStream;
    }

    public Client(){}

    public Client(Socket socket) throws  IOException{
        init(socket);
    }

    public Client(String ip, int port, ArrayList<ClientListener> clientListeners) throws UnknownHostException, IOException{
        if (clientListeners != null){
            addClientListener(clientListeners);
        }
        init(new Socket(ip,port));
    }

    public Client(String ip, int port, ClientListener clientListener) throws UnknownHostException, IOException{
        if (clientListener != null){
            addClientListener(clientListener);
        }
        init(new Socket(ip,port));
    }

    public Client(Socket socket, ClientListener clientListener) throws  IOException{
        if (clientListener != null){
            addClientListener(clientListener);
        }
        init(socket);
    }

    void init(Socket socket) throws IOException{
        if (this.isConnected()) {return;}
        setConnected(false);
        setSocket(socket);
        setOutputStream(new DataOutputStream(getSocket().getOutputStream()));
        setInputStream(new DataInputStream(getSocket().getInputStream()));
        setClientReceiveMessages(clientReceiveMessages);
        connected();
        ClientReceiveMessages clientReceiveMessages = new ClientReceiveMessages(this);
        clientReceiveMessages.start();
        Runtime.getRuntime().addShutdownHook(new ClientShutdownHook(this));
    }

    public void write(String data) throws IOException, NotConnectedException{
        write(data.getBytes());
    }

    public void write(byte[] data) throws IOException, NotConnectedException{
        if (!isConnected()){
            throw new NotConnectedException();
        }
        try{
            new DataOutputStream(getOutputStream()).writeInt(data.length);
            getOutputStream().write(data,0, data.length);
            getOutputStream().flush();
        }
        catch(Exception ex){
            ex.printStackTrace();
            stop(false);
            throw ex;
        }
    }

    public void stop() throws IOException{
        stop(true);
    }

    void stop(final boolean volitional) throws IOException{
        try{
            if (!isConnected()){return;}
            setConnected(false);
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    try {
                        for (final ClientListener c : clientListeners){
                            c.stopped(volitional);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
            getInputStream().close();
            getOutputStream().close();
            getSocket().close();
        }
        catch(Exception ex){
            ex.printStackTrace();
            throw ex;
        }
    }

    void connected(){
        setConnected(true);
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    for (final ClientListener c : clientListeners){
                        c.connected();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    void newMessage(final byte[] content){
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    for (final ClientListener c : clientListeners){
                        c.newMessage(content);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

}

class ClientReceiveMessages extends Thread{

    private Client client;
    private Client getClient() {
        return client;
    }
    private void setClient(Client client) {
        this.client = client;
    }
    public ClientReceiveMessages(Client client){
        setClient(client);
    }

    public void run(){
        while(getClient().isConnected()){
            try{
                DataInputStream input = new DataInputStream(getClient().getInputStream());
                int msgSize = input.readInt();
                byte[] buffer = new byte[msgSize];
                input.readFully(buffer);
                getClient().newMessage(buffer);
            }
            catch(Exception ex){
                if (getClient().isConnected()){
                    try {
                        getClient().stop(false);
                    } catch (IOException e) {}
                }
            }
        }
    }

}

class ClientShutdownHook extends Thread {

    private Client client;
    private Client getClient() {
        return client;
    }
    private void setClient(Client client) {
        this.client = client;
    }
    public ClientShutdownHook(Client client){
        setClient(client);
    }

    public void run() {
        try {
            getClient().stop(false);
        } catch (Exception e) {}
    }

}








public interface ClientListener{
    void connected();
    void stopped(boolean volitional);
    void newMessage(byte[] content);
}




public class NotConnectedException extends Exception{
    private static final long serialVersionUID = 7712308961274293935L;
}