$30 off During Our Annual Pro Sale. View Details »

Swallowed Exceptions in Java

ElmarDott
September 23, 2022

Swallowed Exceptions in Java

Exception handling gehört zu den Grundkenntnissen eines Java Entwicklers. Die sichere Verwendung ist nicht so einfach, wie es auf den ersten Blick scheint. Erschwert wird alles noch dadurch, dass viele Bücher die Java Programmierung zum Thema haben, gern auch von der Verwendung von Ausnahmebehandlung wegen schwacher Performanz abraten. Dennoch lassen sich Exceptions im eigenen Code nicht vermeiden. Auch die testgetrieben Entwicklung benötigt Strategien Exceptions effizient zu verarbeiten, um so das Problem auf den Punkt zu bringen. Wie aber setzt man Excetions sinnvoll ein, um auch im Fehlerfall alle wichtigen Informationen beisammen zu haben? Diese Frage behandle ich ausführlich in meinem Vortrag.
--------------------------------------------------------------------------------------------------
Homepage : https://elmar-dott.com
AnchorFM : https://anchor.fm/elmar-dott
Twitter - https://twitter.com/ElmarDott
GitHub - https://github.com/ElmarDott
Lbry - https://lbry.tv/@elmar.dott:8
BitChute - https://www.bitchute.com/channel/3IyCzKdX8IpO/
--------------------------------------------------------------------------------------------------

ElmarDott

September 23, 2022
Tweet

More Decks by ElmarDott

Other Decks in Programming

Transcript

  1. Jc on 2022 G e rmany on l i n

    e © 2022 ElmarDott Swallowed Exceptions
  2. © 2022 Sw a l l owe d Ex c

    e p t i on s Con s u l t an t El ma r Do t t (M. Schulz) studierte an der HS Merseburg Diplominformatik und twittert regelmäßig über alle möglichen technischen Themen. Seine Schwerpunkte sind hauptsächlich Build und Konfiguration Management, Software Architekturen und Release Management. Seit über fünfzehn Jahren realisiert er in internationalen Projekten für namhafte Unternehmen umfangreiche Webapplikationen. Er ist freier Consultant / Trainer. Sein Wissen teilt er mit anderen Technikbegeisterten auf Konferenzen, wenn er nicht gerade wieder einmal an einem neuen Fachbeitrag schreibt. https://elmar-dott.com + Consultant + Writer + Speaker + Trainer +
  3. © 2022 Sw a l l owe d Ex c

    e p t i on s Ag e nd a Ein Déjà vu Die Struktur von Ausnahmen Logging & Testen Informationsfluss Wartbarkeit Microservices
  4. © 2022 Sw a l l owe d Ex c

    e p t i on s De f i n i t i on Ausnahmen sind Sollbruchstellen im Programmfluss die dabei helfen eine Routine in einem vorausgesagten Fehler - Szenario sicher zu terminieren. https://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html Oracle: Eine Ausnahme ist ein Ereignis, das während der Ausführung eines Programms auftritt und den normalen Ablauf der Programmanweisungen unterbricht.
  5. © 2022 Sw a l l owe d Ex c

    e p t i on s Kn a p p d an e b e n public void foo() { try { String content = Files.readString(Path.of("file.txt")); try { int size = Cipher.getMaxAllowedKeyLength("AES"); } catch (NoSuchAlgorithmException ex) { // do something } } catch (IOException ex) { // do something } }
  6. © 2022 Sw a l l owe d Ex c

    e p t i on s Ed i t o r h i n t s
  7. © 2022 Sw a l l owe d Ex c

    e p t i on s Le h rb u c h-W i s s e n public void foo() throw UnexpectedException { try { if(fail) { throw new MyOwnException(’message’); } } catch (Exception ex) { System.err.println(ex.getMessage()); } finally { // clean up } }
  8. © 2022 Sw a l l owe d Ex c

    e p t i on s Te s t e n I @Test void check() throws MyException { assertThrows(MyException.class, () -> { MyObject.foo(); }); }
  9. © 2022 Sw a l l owe d Ex c

    e p t i on s Dr e am T e am Logging & Test Driven Development Maven / Junit 5 / Logback
  10. © 2022 Sw a l l owe d Ex c

    e p t i on s Wa r t b a rk e i t - API D e s i g n • Entkoppeln von Abhängigkeiten • Pattern: Proxy, Wrapper & Facade • Auch Ausnahmen von Bibliotheken sollten gekapselt werden
  11. © 2022 Sw a l l owe d Ex c

    e p t i on s Ja c k s on JSON public String serializeAsJsonObject(final T object) throws MyJsonProcessingException { try { ObjectMapper mapper = new ObjectMapper(); return mapper.writeValueAsString(object); } catch (JsonProcessingException ex) { throw new MyJsonProcessingException(ex.getOriginalMessage()); } }
  12. © 2022 Sw a l l owe d Ex c

    e p t i on s My Own Pr i v a t e - Ex c e p t i on s public class MyException extends Exception { public MyException(final String msg) { super(msg); } }
  13. © 2022 Sw a l l owe d Ex c

    e p t i on s Te s t e n II @Test() void exceptionObject() { MyException ex = new MyException("MyException"); assertEquals("MyException", ex.getMessage()); }
  14. © 2022 Sw a l l owe d Ex c

    e p t i on s H i e ra r c h i e Exception
  15. © 2022 Sw a l l owe d Ex c

    e p t i on s Er r o r V s Ex c e p t i on • sg. ungeprüfte Ausnahmen • stellen schwere Fehler dar OutOfMemoryError • terminiert das Programm • können auch ‚gefangen‘ werden
  16. © 2022 Sw a l l owe d Ex c

    e p t i on s We r f e n & Fang e n Nicht jede Methode ist geeignet um Exceptions zu fangen bzw. zu werfen. • Regel 1: Low Level Methoden werfen Exceptions • Regel 2: High Level Methoden fangen Exceptions • Regel 3: alles dazwischen leitet ‚nur‘ durch
  17. © 2022 Sw a l l owe d Ex c

    e p t i on s Be i s p i e l • Hibernate ORM – EntityManager // werfen • DAO Klassen oder ähnliche Konstrukte delegieren die Ausnahme nach ‚oben‘ • es werden dadurch keine Informationen „verschluckt“ • Service Klassen / UI etc. leiten dann die Fehlerbehandlung ein
  18. © 2022 Sw a l l owe d Ex c

    e p t i on s Anwe nd u ng public void foo() throw UnexpectedException { try { if(fail) { throw new MyOwnException(’message’); } } catch (Exception ex) { System.err.println(ex.getMessage()); } finally { // clean up } }
  19. © 2022 Sw a l l owe d Ex c

    e p t i on s Nu l lPo i n t e rEx c e p t i on public List<Integer> foo() { List<Integer> result = new ArrayList<>(); // do something return result; }
  20. © 2022 Sw a l l owe d Ex c

    e p t i on s M i c r o s e r v i c e s public Response fetchRes(@PathParam("res") String resName) { Response response = null; try { ResourcesDO resource = resourceDAO.find(resName); response = Response.status(Response.Status.OK) .type(MediaType.APPLICATION_JSON) .entity(resourceDAO.asJson(resource)) .encoding("UTF-8") .build(); } catch (EmptyResultDataAccessException | NoResultException ex) { response = Response.status(Response.Status.NOT_FOUND).build(); } catch (Exception ex) { response = Response.status(Response.Status.INTERNAL_SERVER_ERROR).build(); } return response; }
  21. © 2022 Sw a l l owe d Ex c

    e p t i on s Re f e r e n z e n [1] https://www.yegor256.com/2022/08/30/dont-group-exception- catchers.html [2] Clean Code, 2009, Robert C. Martin, ISBN 0-13-235088-2 [3] Effective Java 3rd Edition, 2018, Joshua Bloch, ISBN-10: 0- 13-468599-7 Marco Schulz, 2021, Continuous Integration mit Jenkins, Rheinwerk, ISBN: ISBN 978-3-8362-7834-8 https://www.rheinwerk-verlag.de/continuous-integration-mit- jenkins/
  22. © 2022 Sw a l l owe d Ex c

    e p t i on s Cr e d e n t i a l s --------------------------------------------------------- Homepage : https://elmar-dott.com GitHub : https://github.com/ElmarDott AnchorFM : https://anchor.fm/elmar-dott Twitter : https://twitter.com/ElmarDott Speaker Deck : https://speakerdeck.com/elmardott Lbry : https://lbry.tv/@elmar.dott:8 BitChute : https://www.bitchute.com/channel/3IyCzKdX8IpO/ --------------------------------------------------------- Danke / thank you / Gracias
  23. None