Modèle de construction pour les méthodes avec traitement des exceptions

Question

J'ai quelques méthodes qui ressemblent à ceci :

public void do(A a, B b);

public void do(A A, C c);

public void do(D d, A a);

public void do(D d, E e, X x, F f, Optional<A> a);

Et ainsi de suite, il existe une douzaine de méthodes qui font à peu près la même chose mais avec des paramètres différents.

J'ai alors pensé à utiliser un modèle de construction qui me permettrait d'utiliser la fonctionnalité comme ceci :

withA(a).withB(b).withX(x).do();

Cependant, le problème est que l'une des dizaines de méthodes lève une exception. Si j'utilise un modèle de construction, alors do() devra lancer cette exception et donc tous les clients devront la gérer. À mon avis, cela ressemble à un problème.

Ma question :

• Est-ce un problème ?
• Si c'est le cas, comment l'éviter ?

Answer 1

Oui. C'est un problème.

Vous pouvez :

1. Attrapez l'exception si vous savez comment la gérer et si le champ à définir est facultatif.

2. Mais si une exception est levée lorsque vous essayez de définir un champ obligatoire, cela signifie que quelque chose ne va pas et que toute l'opération doit échouer.

Answer 2

Il y a toujours la solution simple consistant à "transformer l'erreur en une RuntimeException".

Il suffit d'avoir un try/catch ; et dans le catch, créer une nouvelle RuntimeException pour envelopper l'exception vérifiée - et la relancer. Et un document dans la javadoc.

Answer 3

Vous pourriez changer de contexte lorsque vous utilisez comme paramètre le type qui se trouve être à l'origine de l'exception.

N'oubliez pas que ce n'est pas l'idée la plus brillante, et qu'il ne faut probablement pas l'encourager.

Exemples de constructeurs :

class ParamA{}    
class ParamB{}

class Builder {

    // ... More Stuff ...

    public Builder with(ParamA p){
        // x happens here
        return this;
    }

    public BuilderB with(ParamB p){
        // y happens here
        return new BuilderB(this);
    }

    public void doWork(){
        System.out.println("I did my stuff");
    }
}

class BuilderB{
    private BuilderB(){}

    public BuilderB(Builder b) {
        //Initialize with stuff from b
    }

    public BuilderB with(ParamB p){
        // y happens here
        return this;
    }
    public BuilderB with(ParamA p){
        // x happens here
        return this;
    }

    public void doStuff() throws Exception{
        throw new Exception("poof");
    }
}

Utilisation :

void example() {

    ParamA a = new ParamA();
    ParamB b = new ParamB();

    // doWork in builder doesn't throw, we're good
    new Builder().with(a).with(a).doWork();

    try {
        // stuff in BuilderB trhows, surround w/ try catch
        c.new Builder().with(a).with(b).doStuff();
    } catch (Exception ex) {
        System.out.println("Exception goes " + ex.getMessage());
    }
}