Meilleur modèle de conception pour le chaînage API en JAVA

Ce qui suit vient à l'esprit:

1. Pour les appels de fonction qui renvoient un objet: ne renvoyez jamais null.
2. Pour les appels de fonction qui ne renvoient rien (sinon): return this.
3. Acceptez les interfaces fonctionnelles dans votre API afin que les utilisateurs puissent personnaliser le comportement
4. Pour les objets avec état qui exposent l'API comme décrit ci-dessus, fournissez un modèle de constructeur afin que les utilisateurs ne finissent pas par choisir entre les constructeurs
5. Toutes les méthodes du constructeur décrites doivent être nulles, et retournez donc this

, Vous pouvez créer un ResponseStringBuilder classe qui prend un Function<Response,String> pour obtenir le String de la Response.

public ResponseStringBuilder {
    private Request request;
    public StringBuilder resultBuilder = new StringBuilder();
    public ResponseBuilder(Request req) {
        this.request = req;
    }
    public ResponseStringBuilder fromExtractor(Function<Request, Response> getResponse, Function<Response,String> extract) {
        Response response = getResponse.apply(request);
        resultBuilder.append(extract.apply(response));
        return this;
    }
    public String getResult() {
         return resultBuilder.toString();
    }
}

Qui ferait vos appels

ResponseStringBuilder builder = new ResponseStringBuilder(req);
@SuppressWarnings("unchecked")
Function<Response,String> extractors = new Function[] {
    Response::getABC, Response::getXYZ 
};
for (Function<Response,String> ext : extractors) {
    builder = builder.fromExtractor(this::execute, ext);
}
System.out.println("final response: " + builder.getResult());

Je ne sais pas si la déclaration de tableau se compile réellement, mais cela devrait fonctionner avec des modifications mineures et vous obtenez l'essentiel.

Vous pouvez utiliser un CompletableFuture pour implémenter des promesses en Java. Le problème est que vous essayez de transmettre deux choses différentes dans le "pipeline": la demande, qui est mutable et (parfois) change, et le résultat, qui est accumulé au cours des appels.

J'ai contourné cela en créant une classe appelée Pipe qui a une requête et l'accumulateur pour les résultats jusqu'à présent. Il a getters pour les deux, et il a quelques méthodes pratiques pour renvoyer un nouvel objet avec les résultats accumulés ou même muter la demande et accumuler en un seul appel. Cela rend le code de l'API enchaînant beaucoup plus propre.

Les méthodes with* après les champs, le constructeur et les getters sont celles qui gèrent l'accumulation et la mutation. La méthode chain met tout cela ensemble:

import java.util.concurrent.CompletableFuture;

public class Pipe {
    private Request req;
    private String out;

    public Pipe(Request req, String out) {
        this.req = req;
        this.out = out;
    }

    public Request getReq() {
        return req;
    }

    public String getOut() {
        return out;
    }

    public Pipe with(String data) {
        return new Pipe(req, out + data);
    }

    public Pipe withABC(String abc, String data) {
        req.setABC(abc);
        return new Pipe(req, out + data);
    }

    public Pipe withXYZ(String xyz, String data) {
        req.setXYZ(xyz);
        return new Pipe(req, out + data);
    }

    public static void chain(Request req) throws Exception {
        var promise = CompletableFuture.supplyAsync(() -> new Pipe(req, ""))
        .thenApply(pipe -> {
            Response res = execute(pipe.getReq());
            return pipe.withABC(res.getABC(), res.getOut());
        })
        .thenApply(pipe -> {
            Response res = execute(pipe.getReq());
            return pipe.withXYZ(res.getXYZ(), res.getOut());
        })
        .thenApply(pipe -> {
            Response res = execute(pipe.getReq());
            return pipe.with(res.getOut());
        });

        var result = promise.get().getOut();

        System.out.println(result);
    }

    public static Response execute(Request req) {
        return req.getResponse();
    }
}

Parce qu'il s'exécute de manière asynchrone, il peut lancer InterruptedException, et il peut également lancer ExecutionException si quelque chose d'autre se casse. Je ne sais pas comment vous voulez gérer que, je viens donc de déclarer chain à jeter.

Si vous vouliez appliquer n opérations dans une boucle, vous devez continuer à réaffecter la promesse, comme suit:

var promise = CompletableFuture.supplyAsync(() -> new Pipe(req, ""));

for (...) {
    promise = promise.thenApply(pipe -> {
        Response res = execute(pipe.getReq());
        return pipe.with(res.getOut());
    });
}

var result = promise.get().getOut();

J'ai utilisé Java 10 inférence de type avec var ici, mais les types de promise et result est CompletableFuture<Pipe> et String, respectivement.

(Note: il pourrait être préférable de rendre Request immuable et de passer un nouveau, modifié le long du pipeline plutôt que de le muter. D'autre part, vous pouvez également envelopper un StringBuilder au lieu d'un String, et que les données que vous accumulez soient également mutables. En ce moment, c'est un mélange étrange de mutable et d'immuable, mais cela correspond à ce que faisait votre code.)