Wie fangen vermeiden komplizierte Blöcke

Question

Duplizieren habe ich diesen Code:

try { 
    do_stuff(); 
    return do_more_stuff(); 
} catch (UnsupportedEncodingException e) { 
    throw CustomException.programmer_error(e); 
} catch (ProtocolException e) { 
    throw CustomException.programmer_error(e); 
} catch (MalformedURLException e) { 
    throw CustomException.programmer_error(e); 
} catch (SocketTimeoutException e) { 
    throw new CustomException(e); 
} catch (IOException e) { 
    throw CustomException.unexpected_error(e); 
} 

ich jetzt all diese catch-Blöcke in einer anderen ähnlichen Funktion haben muß. Was ist der beste Weg, um Doppelarbeit zu vermeiden?

Beachten Sie, dass der Code in den beiden try-Blöcken nicht sehr ähnlich ist.

Auch ich kann nicht wirklich den Satz von Fängen höher setzen.

Hinweis, würde ich lieber vermeiden:

try { 
    do_stuff(); 
    return do_more_stuff(); 
} catch (Exception e) { 
    handle_exception_via_rtti(e); 
} 

Answer 1

Persönlich würde ich versuchen, die

do_stuff(); 
return do_more_stuff(); 

Teil einer allgemeineren Format, um Strategie anzuwenden konform zu machen (als Muster).

Dann können Sie alle Orte umgestalten, an denen Sie diese Art von Block aufrufen, so dass sie einen verallgemeinerten Block aufrufen können (wo die Fänge nur einmal angelegt werden).

Answer 2

Hinweis, würde ich lieber vermeiden:

Dann entweder nur mit ihr leben, oder warten, bis JDK7 kommt mit Multicatch, so dass Sie wie:

try { 
    do_stuff(); 
    return do_more_stuff(); 
} catch (UnsupportedEncodingException | ProtocolException | MalformedURLException e) { 
    throw CustomException.programmer_error(e); 
} catch (SocketTimeoutException e) { 
    throw new CustomException(e); 
} catch (IOException e) { 
    throw CustomException.unexpected_error(e); 
} 

Sie können dies auch in den Konstruktor CustomException verschieben und einen (fiesen) globalen Catch ausführen, aber dann müssen Sie eine Reihe von (bösartigen) if/else Blöcken hinzufügen, um den Typ der Ausnahmeursache zu bestimmen. Alles in allem würde ich es vorziehen, bei dem Weg zu bleiben, den Sie bereits getan haben.

Update: Eine andere Alternative ist, die Zeilen zu spalten/umzuformen, die möglicherweise die Ausnahme als separate Aufgaben in eine andere Methode wirft werfen CustomException wirft. Z.B.

try { 
    do_stuff_with_encoding(); 
    do_stuff_with_url(); 
    do_stuff_with_ws(); 
    // ... 
    return do_more_stuff(); 
} catch (SocketTimeoutException e) { 
    throw new CustomException(e); 
} catch (IOException e) { 
    throw CustomException.unexpected_error(e); 
} 

... 

public SomeObject do_stuff_with_encoding() throws CustomException { 
    try { 
     do_stuff(); 
    } catch (UnsupportedEncodingException e) { 
     throw CustomException.programmer_error(e); 
    } 
} 

public SomeObject do_stuff_with_url() throws CustomException { 
    try { 
     do_stuff(); 
    } catch (MalformedURLException e) { 
     throw CustomException.programmer_error(e); 
    } 
} 

public SomeObject do_stuff_with_ws() throws CustomException { 
    try { 
     do_stuff(); 
    } catch (ProtocolException e) { 
     throw CustomException.programmer_error(e); 
    } 
} 

Answer 3

Es hängt davon ab, warum die do_stuff und do_more_stuff die geprüften Ausnahmen werfen. Machen sie das, um den Benutzer zu zwingen, die Ausnahme zu behandeln? Wenn ja, dann versuchen Sie zu vermeiden:

try { 
    do_stuff(); 
    return do_more_stuff(); 
} catch (Exception e) { 
    handle_exception_via_rtti(e); 
} 

ist eine gute Sache.

Wenn Ihr Code nur Exception fängt, und die do_stuff und do_more_stuff später zusätzliche Ausnahmen hinzufügen, werden Sie wahrscheinlich nie wissen, über die Änderung und die Tatsache, dass Ihr Code jetzt falsch sein könnte.

Sie müssen sich also möglicherweise mit throwing the kitchen sink befassen und alle diese Ausnahmen behandeln, es sei denn, die Methoden könnten auf ungeprüfte Ausnahmen wechseln.

Auf der anderen Seite, wenn die Methoden checked Ausnahmen werfen, nur weil der Programmierer war faul in der Behandlung mit ihnen und wollte nur den Bock übergeben, vielleicht sehen Sie dies aus dem falschen Blickwinkel.

Answer 4

Wie über eine generische Action-Klasse einzuführen, die subclassed werden können:

public class Action { 
    public void runWithHandlers() throws Exception { 
     try { 
      run(); 
     } catch (UnsupportedEncodingException e) { 
      throw CustomException.programmer_error(e); 
     } catch (ProtocolException e) { 
      throw CustomException.programmer_error(e); 
     } catch (MalformedURLException e) { 
      throw CustomException.programmer_error(e); 
     } catch (SocketTimeoutException e) { 
      throw new CustomException(e); 
     } catch (IOException e) { 
      throw CustomException.unexpected_error(e); 
     } 
    } 
    public void run() throws Exception { 
     // TODO subclasses of Action must implement this 
    } 
} 

Dann woanders in Ihrem Code instanziiert eine der Unterklassen von Aktion und rufen runWithHandlers():

new MyAction().runWithHandlers(); 

Answer 5

Wenn Sie sich Scala leisten können, überprüfen Sie es: Sie können die Ausnahme im Catch-Block mit dem Muster vergleichen. Siehe Scala for Java Refugees Part 4: Pattern Matching and Exceptions.