Which design pattern for combination of objects in Java?

Question

I am looking for the best approach to design the following system :

• I have a class of object, called Compilers (C, Go..Etc)
• I have another class of object, called Protocols (HTTP, RPC, WEBSOCKET..Etc)
• I have another class of object, called Serialization (BINARY, JSON..Etc)

Now each compiler has to be matched with the right implementation of the protocol and the serialization.

For instance, if the compiler is C, then it should be matched with CProtocolHTTP or CProtocolRPC w.r.t the protocol and CSerializationBinary or CSerializationJson w.r.t Serialization, if the compiler is Go it should be matched with GoProtocolHTTP or GoProtocolRPC w.r.t the protocol and GoSerializationBinary or GoSerializationJson w.r.t Serialization.

The client should have the choice to choose any combination :

• Go with HTTP and BINARY
• Go with HTTP and JSON
• Go with RPC and BINARY
• C with HTTP and JSON ...etc

I tried Factory and Strategy but I was unable to make them work in a neat way.

What would be the right design patterns to use in order to implement this in Java ?

Answer 1

I'm note sure you really need any specific design pattern to solve your problem. I think using dependency injection should be sufficient.

The most important thing is to require both a protocol and a serialization mechanism to be provided when creating a compiler. This can be enforced in the compiler's constructor.

First declare all the supported protocols under a common interface:

public interface Protocol
{
    //...
}
public final class Http implements Protocol
{
    //...
}
...

The same for serialization

public interface Serialization
{
    //...
}
public final class Binary implements Serialization
{
   //...
}
...

Then each possible compiler can be declared as follow

public interface Compiler
{
    //...
}
public final class Go implements Compiler
{
    private final Protocol protocol;
    private final Serialization serialization;
    public GoCompiler(Protocol protocol, Serialization serialization)
    {
        this.protocol = protocol;
        this.serialization = serialization;
    }
    //...
}
...

Final usage will looks like this:

Compiler c1 = new Go(new Http(), new Binary());
Compiler c2 = new Go(new Http(), new Json());
Compiler c3 = new Go(new Rpc(), new Binary());
Compiler c4 = new C(new Http(), new Binary());

Answer 2

If the Protocol and Serialization classes are independent of each other, but both depend on the Compiler, then this situation fits the Abstract Factory pattern.

In essence, you would have two factory classes for each Compiler to create the correct Protocol instances and one to create the Serialization instances.

In pseudo-code, the class structure could look something like this.

interface IProtocolFactory {
  IProtocol createHttp()
  IProtocol createRpc()
  ...
}

interface ISerializationFactory {
  ISerializer createJson()
  ...
}

interface IFactoryFactory {
  IProtocolFactory getProtocolFactory()
  ISerializationFactory getSerializationFactory()

  static IFactoryFactory getFactory(Compiler x)
  {
    if x == C then return new CObjectsFactory()
    if x == Go then return new GoObjectsFactory()
    ...
  }
}

class CObjectsFactory implements IFactoryFactory {
  IProtocolFactory getProtocolFactory() 
  { 
    return new CProtocolFactory() 
  }
  ISerializationFactory getSerializationFactory()
  { 
    return new CSerializationFactory() 
  }
}

class CProtocolFactory implements IProtocolFactory {
  IProtocol createHttp()
  { 
    return new CProtocolHTTP() 
  }
}