Today, all clients and servers follow the builder pattern to make sure that a client/server once created in immutable. In order to make the creation of most common clients/server easy, RxNetty factory class has some factory methods, like:

    public static RxServer<ByteBuf, ByteBuf> createTcpServer(final int port,
                                                             ConnectionHandler<ByteBuf, ByteBuf> connectionHandler);
    public static HttpServer<ByteBuf, ByteBuf> createHttpServer(int port, RequestHandler<ByteBuf, ByteBuf> requestHandler);

It also has the following builder creation methods:

public static <I, O> ServerBuilder<I, O> newTcpServerBuilder(int port, ConnectionHandler<I, O> connectionHandler);
public static <I, O> HttpClientBuilder<I, O> newHttpClientBuilder(String host, int port);

The above two concepts are a bit odd as a user has to unlearn one to learn the other. eg: If one needs to enable wire-level logging, there is no way, one can do that while creating a client/server. One, has to use the builder.

Proposal

• Fold all builder methods into the main client/server. Every invocation of those methods, should create a new instance of client/server.
• Replace inheritance with delegation in clients/servers. In absence of this change, the client/server have to introduce a generic parameter which will guide what to return from these methods which create a new client/server. The downside is that an HttpClient can not be used as an RxClient. The usage of this aspect is very limited as once, a user uses an HttpClient, there is very little use of using #connect() on the client.

After this change, users of a particular client/server would just have to be aware of any APIs on that client/server and nothing else. There will be less abstractions and less confusion.