Agfdhyk

I'm currently working on a protocol handler for a project of mine in Java. I am trying to create a maintainable and extensible API, meaning I do not want to simply hardcode in supported value types.

I have begun designing a 'protocol handler' that given a value (of a supported type) can encode that value according to the specification of the protocol, without the client worrying about the details of the translation process.

Different value types e.g. Strings or Integers necessarily have different encoding processes, but I don't want clients to worry about holding references to a different object for each possible type they may need to encode - as I said I don't want them to worry about the details.

So far I have defined a 'generic' DynamicHandler class that maintains a collection of 'specific' type aware StaticHandlers:

class DynamicHandler

{

  Map<Class, StaticHandler> handlers;



  <T> void handle(T value)

  {

    if(handlers.containsKey(value.class))

      handlers.get(value.getType()).handle(value);

  }



  void <T> register(StaticHandler<T> handler)

  {

    handlers.put(T.class, handler);

  }

}

The idea of this class is that a client simply passes a value they want to encode to the handle method and the DynamicHandler looks up and delegates to the StaticHandler.

interface StaticHandler<T>

{

  void handle(T value);

}

Here an example of some client that uses this system:

class StringHandler implements StaticHandler<String>

{

  void handle(String value)

  {

    ...

  }

}



DynamicHandler handler = new DynamicHandler();

handler.register(new StringHandler());

handler.handle("Hello World!");

I have two questions which I am struggling to find an answer to on my own:

1. In the DynamicHandler.register method, how can I get the type of T without having an instance of T?


2. Is it possible to implement the DynamicHandler type as a java.util.Map, in order to maximise compatibility with any 3rd party code clients, may use to build or otherwise process such objects?

Edit: Since DynamicHandler is essentially a Map, albeit with some generic trickery going on, is it possible to implement it as: DynamicHandler implements java.util.Map<...,...> (I'm not exactly sure what the Key and Value types should be here).

This is my first time asking a question on here, so I hope that I have been clear enough for you all. If there is anything you think needs clarifying just let me know and I will try my best.

If null values are not handled and that it is designed such that there would never be any value that belongs to multiple classes, then you could do this:

public class DynamicHandler {

    Map<Class, StaticHandler> handlers;



    public <T> void handle(T value) {

        if(value != null) {

            handlers.entrySet()

                    .stream()

                    .filter(entry -> 

                        entry.getKey().isInstance(value))

                    .findAny()

                    .ifPresent(entry ->

                        entry.getValue().handle(value));

        }

    }



    public void <T> register(StaticHandler<T> handler) {

        handlers.put(handler.getHandlingClass(), handler);

    }

}





interface StaticHandler<T>

{

    void handle(T value);

    Class<T> getHandlingClass();

}



public class StringHandler implements StaticHandler<String> {

    @Override public void handle(String value) {

        ...

    }

    @Override public final Class<String> getHandlingClass() {

        return String.class;

    }

}

1. In the DynamicHandler class, how can I get the type of T without having an instance of T?

The common solution for this is to pass it a Class object:

 void <T> register(StaticHandler<T> handler, Class<T> clazz)

  {

    handlers.put(clazz, handler);

  }

Just as one example of this in a commonly used library: Gson does something similar to register JSON serializers for specific types with GsonBuilder.registerTypeHierarchyAdapter