Java - Integrar patrón Command en un programa

Estoy haciendo un pequeño programa de chat mediante Sockets y ServerSockets.
He creado las clases de la capa más baja del programa (User, UserListener, MsgBuffer, BufferListener, etc...) y ahora me queda agruparlas para que funcionen entre ellas.
La cosa está en que quisiera poder integrar en el prorgama un sitema de comandos lo más flexible possible, que le permita al usuario hacer exactamente lo mismo que puede hacer gráficamente y más (modificar el estado interno de las clases del programa).

Para hacer esto tengo pensado crear una interfaz Commandable con el método executeCommand(Command command); a partir de ahí, implementarla en las clases que puedan ejecutar comandos.
El problema que tengo aquí, y por esto creo este post, es que no se me ocurre ninguna forma de redirigir el comando introducido por el usuario a la clase que lo tiene que ejecutar con el método executeCommand(Command command);.

He leído sobre el patrón CommandPattern, pero los artículos que he encontrado tan solo hablan de como usar este patrón y no de como estructurar un programa para integrarle un CommandPattern.
Muchas gracias de antemano :D

Ahora releyendo me doy cuanta que se me olvidó mencionar que hay mucha encapsulación en este programa, y que hay elementos complejos a los que me gustaría intergarles comandos, que no tienen ni getters ni setters en la clase que los encapsula...

No sé si entiendo tu proceso ... ¿ Qué es lo que se puede hacer gráficamente ? ¿ Cómo imaginas esos "comandos" ? ¿ Te refieres a hacer cosas en tu cliente (por ejemplo tu propio escritorio) o en el remoto (el de la persona con quien chateas) ?

El sistema de chat permitirá crear usuarios, eliminarlos, crear grupos de estos, redirigir mensajes, mutear personas, crear salas de chat, y si se me ocurren más cosas me gustaría añadirlas. Quiero que sea completo, por esto he creado un montón de clases en plan "mis librerias" que tengo que unir.
El problema está en que al unirlas, pues cuando tenga una clase encapsulada en otra clase que a su vez está encapsulada en otra, para llamar al método executeCommand desde la clase que contiene el HashTable (new HashTable<String, Commandable>()), (la que llama a los comandos) lo tendré muy muy complicado.

Sobre lo que me gustaría poder hacer con comandos sería algo así como poder crear una conexión con una IP, configurar hacia donde redirigir los datos del stream (a otra IP para hacer de puente por ejemplo), crear nuevos grupos de usuarios...

La verdad es que me siento muy perdido en este punto del desarrollo.. :(

Poco a poco voy avanzando y se me ha ocurrido un patrón que solucionaría este problema (los elementos de todas las clases están encapsulados y por lo tanto no puedo acceder a ellos desde fuera), pero en mi opinión es una porquería.
Estas líneas quizás sean complicadas de entender, ya que explicar un patrón en texto es complicado:

La cosa estaría en hacer que todas las clases del programa implementen Commandable, que contiene el metodo executeCommand(Command command);.
Cada una de estas clases contendría en su interior clases privadas con el nombre de cada comando, estas clases privadas también implementarían Commandable. Para ejecutar los comandos se haría algo del estilo:
En caso de que el comando no pueda ser ejecutado en esta clase (osea, que la clase privada con el nombre del comando no existe), pero si en alguna de las clases encapsuladas por esta, se llama al executeCommand de estas clases que a su vez hacen lo mismo.

Este patrón yo lo veo horrendo, más que nada porque en cada clase hay que estar escribiendo un executeCommand específico para llamar manualmente a este método en todas las clases que esta contenga en su interior.
Imagina que una clase, por lo que sea tiene dentro 45 clases distintas y encapsuladas. Tendría que llamar a executeCommand(command) manualmente 45 veces...

Parece complejo, quizás has "sobrediseñado" un poco.
¿ Por qué no pruebas a rediseñar "de abajo a arriba", implementando tus clases pensando ya en los comandos (un botón del ui lo que hará será ejecutar un comando) ? Seguramente te quedará una jerarquía de clases bastante más sencilla.
El "parser" de los comandos ... se podría hacer con reflection (como en el ejemplo que pones) pero quizás sería más claro que tuvieras una clase "Command", y un método Command.execute() ... en lugar de hacer todas tus clases "Commandable()"