Fluent-API mit Vererbung und generics

Dein code ist grundsätzlich eine unsichere Verwendung von Generika. Zum Beispiel, wenn ich Schreibe, eine neue Klasse, die erweitert die Nachricht, sagen Bedrohlich, und hat eine neue Methode doSomething(), und dann erstelle ich eine Meldung parametriert, die von dieser neuen Klasse, und es erstellt eine Instanz der Nachricht und versucht dann, warf es zu seiner Unterklasse. Da es sich jedoch um eine Instanz der Nachricht, und nicht der Gefahr, ein Versuch zum aufrufen dieser Meldung zu einer Ausnahme führen. Da es nicht möglich ist, für die Nachricht von doSOmething().

Weiter, es ist auch unnötig zu verwenden, Generika hier. Plain old Vererbung funktioniert. Da die sub-Typen kann Methoden überschreiben, indem Sie Ihre Rückgabetypen mehr bestimmte, die man haben kann:

public abstract class Message {

    protected Message() {

    }

    public Message withID(String id) {
        return this;
    }
}

Dann

public class CommandMessage extends Message {

    protected CommandMessage() {
        super();
    }

    public static CommandMessage newMessage() {
        return new CommandMessage();
    }

    public CommandMessage withCommand(String command) {
        return this;
    }
}

Diese funktionieren, auf dem Verständnis, dass Sie Ihre Argumente in der richtigen Reihenfolge:

CommandWithParamsMessage.newMessage()
    .withID("do")
    .withCommand("doAction")
    .withParameter("arg", "value");

wird nicht funktionieren, aber

CommandWithParamsMessage.newMessage().withParameter("arg", "value")
.withCommand("doAction").withID("do")

Erfolgreich sein wird, da es nur "up-Typen", schließlich der Rückkehr eine "message" - Klasse. Wenn Sie wollen, dass es nicht zu "uptype", dann überschreiben Sie einfach die geerbte Befehle, und jetzt können Sie die Methoden aufrufen, die in beliebiger Reihenfolge, da Sie alle wieder die ursprüngliche Art.

E. g.

public class CommandWithParamsMessage extends
CommandMessage {

    public static CommandWithParamsMessage newMessage() {
        return new CommandWithParamsMessage();
    }

    public CommandWithParamsMessage withParameter(String paramName,
        String paramValue) {
        contents.put(paramName, paramValue);
        return this;
    }

    @Override
    public CommandWithParamsMessage withCommand(String command){
        super.withCommand(command);
        return this;
   }

    @Override
    public CommandWithParamsMessage withID(String s){
        super.withID(s);
        return this;
    }
}

Nun werden Sie fließend Rückkehr eine CommandWithParamsMessage mit den beiden fließend Anrufe vor.

Tut dies Ihr problem lösen, oder habe ich das falsch verstanden, deine Absicht?

Wenn Sie ändern Sie die Signaturen wie diese sollten Sie weder Warnungen, noch benötigen Sie irgendwelche casts:

abstract class Message<T extends Message<T>> {

    public T withID(String id) {
        return self();
    }

    protected abstract T self();
}

abstract class CommandMessage<T extends CommandMessage<T>> extends Message<T> {

    public T withCommand(String command) {
        //do some work ...
        return self();
    }
}

class CommandWithParamsMessage extends CommandMessage<CommandWithParamsMessage> {

    public static CommandWithParamsMessage newMessage() {
        return new CommandWithParamsMessage();
    }

    public CommandWithParamsMessage withParameter(String paramName, String paramValue) {
        //do some work ...
        return this;
    }

    @Override protected CommandWithParamsMessage self() {
        return this;
    }
}

Ist dies keine Lösung für das ursprüngliche problem. Es ist nur ein Versuch, zu erfassen, Ihre tatsächliche Absicht, und skizzieren einen Ansatz, wo, wo das ursprüngliche problem nicht angezeigt. (Ich mag die Generika - aber Klasse Namen wie CommandMessage<T extends CommandMessage<T>> extends Message<CommandMessage<T>> machen mich schaudern...)

Weiß ich, dass dies strukturell eher anders aus, was Sie ursprünglich gefragt, und Sie haben vielleicht einige details weggelassen bei der Frage, verengen das Spektrum der möglich Antworten, so dass die folgende ist nicht mehr anwendbar.

Aber wenn ich Verstand Ihre Absicht richtig, Sie könnte in Erwägung ziehen, lassen die Subtypen behandelt werden, indem der fließend Anrufe.

Die Idee hier ist, dass Sie zunächst nur erstellen Sie eine einfache Message:

Message m0 = Message.newMessage();
Message m1 = m0.withID("id");

Auf diese Meldung, können Sie die withID Methode - das ist die einzige Methode, die allen Nachrichten gemein haben. Die withID Methode gibt eine Message in diesem Fall.

Bis jetzt, die Nachricht ist weder ein CommandMessage noch eine andere spezielle form. Allerdings, wenn Sie rufen Sie die withCommand Methode, die Sie offensichtlich wollen, zu konstruieren, ein CommandMessage - so dass Sie jetzt einfach wieder ein CommandMessage:

CommandMessage m2 = m1.withCommand("command");

Ebenso, wenn Sie rufen Sie die withParameter Methode, erhalten Sie ein CommandWithParamsMessage:

CommandWithParamsMessage m3 = m2.withParameter("name", "value");

Diese Idee ist in etwa (!) inspiriert von einem blog-Eintrag, die ist in Deutsch, aber der code, der schön zeigt, wie dieses Konzept kann verwendet werden, zu konstruieren, type-safe "Select-From-Where" Abfragen.

Hier der Ansatz wird skizziert, grob abgestimmt für Ihren Anwendungsfall. Natürlich gibt es einige details, in denen die Umsetzung wird davon abhängen, wie diese tatsächlich genutzt werden - aber ich hoffe, dass die Idee klar wird.

import java.util.HashMap;
import java.util.Map;


public class FluentTest
{
    public static void main(String[] args) 
    {
        CommandWithParamsMessage msg = Message.newMessage().
                withID("do").
                withCommand("doAction").
                withParameter("arg", "value");


        Message m0 = Message.newMessage();
        Message m1 = m0.withID("id");
        CommandMessage m2 = m1.withCommand("command");
        CommandWithParamsMessage m3 = m2.withParameter("name", "value");
        CommandWithParamsMessage m4 = m3.withCommand("otherCommand");
        CommandWithParamsMessage m5 = m4.withID("otherID");
    }
}

class Message 
{
    protected String id;
    protected Map<String, String> contents;

    static Message newMessage()
    {
        return new Message();
    }

    private Message() 
    {
        contents = new HashMap<>();
    }

    protected Message(Map<String, String> contents) 
    {
        this.contents = contents;
    }

    public Message withID(String id) 
    {
        this.id = id;
        return this;
    }

    public CommandMessage withCommand(String command) 
    {
        Map<String, String> newContents = new HashMap<String, String>(contents);
        newContents.put("command", command);
        return new CommandMessage(newContents);
    }

}

class CommandMessage extends Message 
{
    protected CommandMessage(Map<String, String> contents) 
    {
        super(contents);
    }

    @Override
    public CommandMessage withID(String id) 
    {
        this.id = id;
        return this;
    }

    public CommandWithParamsMessage withParameter(String paramName, String paramValue) 
    {
        Map<String, String> newContents = new HashMap<String, String>(contents);
        newContents.put(paramName, paramValue);
        return new CommandWithParamsMessage(newContents);
    }

}

class CommandWithParamsMessage extends CommandMessage 
{
    protected CommandWithParamsMessage(Map<String, String> contents) 
    {
        super(contents);
    }

    @Override
    public CommandWithParamsMessage withID(String id) 
    {
        this.id = id;
        return this;
    }

    @Override
    public CommandWithParamsMessage withCommand(String command) 
    {
        this.contents.put("command", command);
        return this;
    }
}