java object oriented textstring protocol

Question 1

If I understand what you mean, basically, a message is something that must

be parsed from a string,
be used to do something.

So, you could have something like

abstract class Message {
    public abstract void doSomething();
    private String myType; // or enum, or whatever

    public String getMyType() {
        return myType;
    }

    public static Message parse(String s) {
        // parse s
        // if s contains command 'register', return a new RegisterMessage
        // if s contains command 'someDataGet', return a new SomeDataGetMessage

        return // a newly created message;
        }
    }

    class MessageRegister extends Message {

    @Override
    public void doSomething() {
        // do what a Register message does          
    }

    public MessageRegister() {
        myType = "REGISTER";
    }

}

class MessageSomeDataGet extends Message {

    @Override
    public void doSomething() {
        // do what a SomeDataGet message does       
    }

    public MessageSomeDataGet() {
        myType = "SOMEDATAGET";
    }
}

Then, you create a new message with

Message m = Message.parse("some command");

You can switch on the message type like this:

switch (m.getMyType()) {
    case "SOMEDATAGET":
        // whatever
}

Question 2

The way I usually do this is with an interface, lets call it ConsoleProgram that takes string arguments and a HashMap that couples a string to a Program. Basically doing something similar to your switch statement and then each Program can worry about its own format when its passed the rest of the string (excluding the first program selecting part of the string)

public interface ConsoleProgram {
    public String getProgramName(); //what the command string starts with to call this program
    public void runProgram(String[] arguments);
}

Then a single class can deal with recieving strings and passing them to ConsolePrograms without ever worrying about what the ConsoleProgram actually does

public class Console{

    public static HashMap<String, ConsoleProgram> availablePrograms=new HashMap<>();


    public void registerProgram(ConsoleProgram program){

        availablePrograms.put(program.getProgramName().toLowerCase(), program);

    }


    public void recieveCommand(String command){

        String[] parts = command.split(" ");

        ConsoleProgram program=availablePrograms.get(parts[0].toLowerCase());

        if (program!=null){
            System.out.println(
                    program.runProgram(Arrays.copyOfRange(parts, 1, parts.length));

        }else{
            System.out.println("program unavailable");
            System.out.println(
                availablePrograms.get("availableprograms").runProgram(parts, this, null)
            );
        }
    }

}

This is something I myself use to support administrative functions within a game I am developing and it scales very nicely. Furthermore if a ConsoleProgram needs access to unusual things you don't need to have Console know about them, the specific ConsoleProgram can take those objects in its constructor before being registered using registerProgram

Question 3

Instead of writing your own serializers/parcers I recommend using one of well-known tools that are created exactly for that.

One of my favourites is protocol buffers from google and there are many others.

With protocol buffers you would need to define your custom message formats (look at their simple java tutorial for reference), and then generate java code for it.

You would do it on both server/client sides, or, I guess you could simply include generated files along with dependency jar in your library and share it between server/clients.

This will have number of benefits :

You won't need to write your serializer/parser (and more importantly spend time debugging it!)
It is flexible, you can change/extend your messages in future
You are not limited to Java implementations, same message format can be understood by other servers/clients written in C++/Python.