• Poznaj techniki programowania, dzięki którym Twoje aplikacje staną się odporne na błędy
• Naucz się przewidywać błędy i zapobiegać ich występowaniu
• Zabezpiecz aplikacje przez skutkami wystąpienia błędów stosując odpowiednie wzorce projektowe

Żaden kod nie jest idealny -- nawet najbardziej doświadczony programista popełnia błędy. Tym, co w takich przypadkach wyróżnia doświadczonego programistę jest fakt, że jego aplikacje posiadają mechanizmy pozwalające na obsługę tych błędów. Dzięki nim program nie zawiesi się ani nie "pogubi" żadnych danych. Oczywiście, aby napisać odpowiednią obsługę wyjątków, należy poznać ich typy oraz mechanizmy ich powstawania. Niezbędna jest również znajomość wzorców projektowych oraz narzędzi do testowania kodu.

W książce "Java. Obsługa wyjątków, usuwanie błędów i testowanie kodu" znajdziesz wszystkie te informacje. Dowiesz się, jak zaimplementować obsługę wyjątków i poprawić jakość kodu źródłowego. Poznasz modele wyjątków i nauczysz się zarządzać mechanizmami ich obsługi na poziomie aplikacji i pojedynczych modułów. Przeczytasz tu także o wzorach projektowych zapewniających prawidłową obsługę wyjątków.

• Koncepcje obsługi wyjątków
• Obsługa wyjątków w aplikacjach wielowątkowych
• Przyczyny występowania wyjątków w różnych elementach języka Java
• Programowanie rozproszone w Javie
• Wyjątki w aplikacjach J2EE
• Wzorce projektowe
• Testowanie kodu i usuwanie błędów

Po przeczytaniu tej książki Twoja wiedza pozwoli Ci na podejmowanie odpowiednich decyzje dotyczące architektury aplikacji i odpowiadającego jej modelu wyjątków.

Osoby które kupowały "Java. Obsługa wyjątków, usuwanie błędów i testowanie kodu", wybierały także:

• Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII 193,23 zł, (59,90 zł -69%)
• Spring i Spring Boot. Kurs video. Testowanie aplikacji i bezpiecze 129,00 zł, (51,60 zł -60%)
• Metoda dziel i zwyci 89,00 zł, (35,60 zł -60%)
• JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)
• Platforma Xamarin. Kurs video. Poziom drugi. Zaawansowane techniki tworzenia aplikacji cross-platform 99,00 zł, (39,60 zł -60%)

Spis treści

Java. Obsługa wyjątków, usuwanie błędów i testowanie kodu -- spis treści

Wstęp (11)

Część I Podstawy obsługi wyjątków (17)

Rozdział 1. Obsługa wyjątków. Wprowadzenie (19)

• Wstęp (19)
  
• Pojęcie wyjątku (22)
  
• Hierarchia klas reprezentujących wyjątki (24)
  
• Opcje związane z przechwytywaniem oraz deklaracją wyjątków (25)
  
  • Przechwytywanie i obsługa wyjątków: bloki try, catch i finally (26)
  • Reguły dotyczące stosowania bloków try-catch-finally (27)
  • Deklarowanie metod zgłaszających wyjątki (28)
  • Reguły dotyczące deklarowania metod zgłaszających wyjątki (28)
• Wyjątki kontrolowane i niekontrolowane (28)
  
• Podstawowe własności każdego wyjątku (29)
  
• Podsumowanie (31)

Rozdział 2. Obsługa wyjątków. Techniki i praktyka (33)

• Wstęp (33)
  
• Kiedy przechwytywać wyjątki, a kiedy je deklarować? (34)
  
• Typowe sposoby obsługi wyjątków (35)
  
  • 1. Zapis błędu lub związanej z nim informacji do dziennika (36)
  • 2. Zwrócenie się do użytkownika z prośbą o podjęcie odpowiedniej decyzji (38)
  • 3. Użycie wartości domyślnych lub alternatywnych (39)
  • 4. Przekazanie sterowania do innej części aplikacji (40)
  • 5. Konwersja wyjątku do innej postaci (40)
  • 6. Zignorowanie problemu (41)
  • 7. Powtórzenie operacji (41)
  • 8. Wywołanie operacji alternatywnej (42)
  • 9. Przygotowanie aplikacji do zamknięcia (42)
• Co należy, a czego nie wolno robić w ramach obsługi wyjątków? (43)
  
• Dobre praktyki (43)
  
  • 1. Obsługuj wyjątki zawsze, gdy jest to możliwe (43)
  • 2. Obsługa wyjątku powinna ściśle zależeć od jego typu (43)
  • 3. Zapisuj do dziennika te wyjątki, które mogą mieć wpływ na działanie aplikacji (44)
  • 4. Dokonuj konwersji wyjątków, jeśli tylko dojdziesz do wniosku, że lepiej reprezentują one istotę problemu (44)
• Czego robić nie należy? (44)
  
  • 1. Nie ignoruj wyjątków, chyba że masz absolutną pewność, iż jest to niegroźne dla działania aplikacji (44)
  • 2. Nie dopuszczaj do zbyt ogólnego traktowania wyjątków (45)
  • 3. Nie dokonuj konwersji wyjątku polegającej na zmianie typu szczegółowego na ogólny (chyba że przechowasz kontekst zdarzenia w inny sposób) (46)
  • 4. Wyjątków lepiej unikać, niż je obsługiwać (47)

Rozdział 3. Zaawansowane koncepcje obsługi wyjątków (49)

• Wstęp (49)
  
• Tworzenie własnych wyjątków (50)
  
  • 1. Definicja klasy wyjątku (51)
  • 2. Deklaracja wyjątku przez metody, które mogą być potencjalnym źródłem błędu (52)
  • 3. Znalezienie tych miejsc, które są bezpośrednią przyczyną wystąpienia błędu, wygenerowanie w nich wyjątków i wyrzucenie ich za pomocą instrukcji throw. (52)
• Łańcuchy wyjątków (54)
  
• Lokalizacja wyjątków (55)
  
  • 1. Stworzenie klasy dziedziczącej po ResourceBundle, która będzie przechowywała opis wyjątku (56)
  • 2. Zdefiniowanie klasy odpowiadającej danemu językowi (57)
  • 3. Definicja klasy wyjątku, w której pokrywamy metodę getLocalizedMessage (57)
• Wyjątki a pokrywanie metod (59)
  
• Deklaracja wyjątków w interfejsach i klasach abstrakcyjnych (60)
  
• Stos wywołań wyjątku (61)
  
• Wyjątki z perspektywy kodu pośredniego (64)

Rozdział 4. Obsługa wyjątków w aplikacjach wielowątkowych (69)

• Wstęp (69)
  
  • Kiedy należy dzielić program na wątki? (70)
• Wyjątki w systemach wielowątkowych (71)
  
• Wyjątki w synchronizowanych blokach kodu (72)
  
• Praca wielowątkowa a ryzyko wystąpienia wyjątku (74)
  
• Wyjątki związane z komunikowaniem się wątków (75)
  
• Zakleszczenie (78)
  
• ThreadDeath (79)

Rozdział 5. Zapis do dziennika i asercje (81)

• Wstęp (81)
  
• Wprowadzenie do Logging API (81)
  
• Kiedy stosować Logging API? (82)
  
• Struktura Logging API (82)
  
• Szczegóły dotyczące używania biblioteki (83)
  
• Konfigurowanie dziennika (88)
  
  • Przykład pierwszy: Proste użycie domyślnego obiektu Logger (88)
  • Przykład drugi: Użycie i konfiguracja kilku obiektów typu Logger (89)
  • Przykład trzeci: Dziennik rozproszony (90)
• Asercje (91)
  
  • Używanie asercji (92)
  • Jak i kiedy korzystać z asercji? (92)

Część II Planowanie obsługi wyjątków (95)

Rozdział 6. Planowanie obsługi wyjątków (97)

• Wstęp (97)
  
• Zasady dobrego projektowania obiektowego (98)
  
  • Projektowanie z uwzględnieniem błędów (103)
  • Etap 1. Identyfikacja przypadku użycia (104)
  • Etap 2. Precyzyjny opis procesu i poszczególnych jego składników (105)
  • Etap 3. Identyfikacja potencjalnych błędów i ocena ich ryzyka (106)
  • Etap 4. Wskazywanie miejsc wystąpienia potencjalnych błędów w ramach operacji (110)
  • Etap 5. Przygotowanie strategii obsługi błędów (111)
  • Projektowanie z myślą o łatwiejszym zarządzaniu - korzyści i wady (113)
  • Identyfikacja błędów (114)
• Podsumowanie (115)

Rozdział 7. Wyjątki a podstawowe elementy języka Java (117)

• Wstęp (117)
  
• Typy podstawowe (118)
  
  • Wprowadzenie (118)
  • Stosowanie (118)
  • Potencjalne problemy (119)
  • Ogólne zalecenia (121)
• Klasa Object i obiekty tego typu (122)
  
  • Wprowadzenie (122)
  • Potencjalne problemy (122)
• Tablice (128)
  
  • 1. Indeksowanie (129)
  • 2. Wielkość tablicy (129)
  • 3. Typ elementów tablicy (129)
• Interfejsy pakietu java.lang (130)
  
• Klasy String i StringBuffer (131)
  
  • Klasa String (132)
  • Klasa StringBuffer (132)
• Klasy BigDecimal i BigInteger (132)
  
• Klasy opakowujące (133)

Rozdział 8. Kolekcje i operacje wejścia-wyjścia (135)

• Wstęp (135)
  
• Biblioteka obsługi kolekcji (135)
  
  • Wprowadzenie (135)
  • Korzystanie z kolekcji (136)
  • Problemy i wyjątki typowe dla kolekcji (141)
• System wejścia-wyjścia (144)
  
  • Problemy typowe dla operacji wejścia-wyjścia (146)
• Błędy i wyjątki w klasach wejścia-wyjścia (148)
  
  • Problemy ogólne (148)
  • Problemy dotyczące strumieni określonego typu (149)
• Biblioteka New I/O (NIO) (156)
  
• Wyjątki w New I/O API (158)
  
  • Bufory (158)
  • Zestawy znaków (159)
  • Kanały (160)
  • Przełączniki (164)

Rozdział 9. Programowanie rozproszone w Javie (167)

• Wstęp (167)
  
• Podstawy komunikacji między aplikacjami (168)
  
  • Modele komunikacji w Javie (170)
  • Dodatkowe zagadnienia związane z pracą rozproszoną (170)
  • Model obsługi wyjątków (172)
  • Typowe problemy (173)
• RMI - zdalne wywoływanie metod (174)
  
  • Model komunikacyjny RMI (174)
  • Typowe zagadnienia związane z używaniem RMI (175)
  • Model wyjątków RMI (178)
• Java Naming and Directory Interface, JNDI (184)
  
  • Typowe zagadnienia związane z JNDI (185)
  • Model wyjątków JNDI (186)
• Java Database Connectivity, JDBC (189)
  
  • Wyjątki w JDBC (189)
  • Ogólne zagadnienia dotyczące obsługi baz danych (191)
  • Cykl życia aplikacji korzystającej z JDBC (193)
• Podsumowanie (198)

Rozdział 10. J2EE (199)

• Wstęp (199)
  
• Podstawowy model aplikacji J2EE (200)
  
  • Model aplikacji J2EE (202)
  • Wyjątki w J2EE (203)
• Warstwa klienta (204)
  
• Warstwa aplikacji sieciowej (206)
  
  • Deklaratywna obsługa błędów (207)
  • Komponenty aplikacji sieciowej (208)
  • Serwlety i filtry: obsługa wyjątków na poziomie programu (209)
  • Model wyjątków serwletów i filtrów (210)
  • Typowe zagadnienia i ryzyko związane z używaniem serwletów (211)
  • Model wyjątków JSP (215)
  • Bezpośrednie przekierowanie błędów w JSP (215)
  • Sposób obsługi wyjątków w JSP (216)
  • Błędy związane z translacją i uruchamianiem stron JSP (217)
  • Biblioteki własnych znaczników (217)
• Warstwa komponentów EJB (218)
  
  • Standardowe metody EJB (219)
  • Ogólne kwestie związane z obsługą EJB (221)
  • Zagadnienia związane z typem komponentu (223)
  • Model wyjątków EJB (225)
  • Zarządzanie cyklem życia komponentów. Metody wywoływane przez klienta (227)
  • Metody komponentu wywoływane przez kontener (230)
  • Wyjątki z punktu widzenia kontenera (231)
• Obsługa transakcji (232)
  
• J2EE i obsługa wyjątków - kwestie ogólne (236)
  
• Czynniki, które należy rozważyć podczas obsługi wyjątków w J2EE (237)
  
  • Obsługa dziennika (237)
  • Koszty związane ze zgłaszaniem wyjątków (238)
  • Obciążenie sieci (239)
  • Inne zalecenia dotyczące systemów J2EE (239)

Część III Skuteczne posługiwanie się wyjątkami i ich obsługa (241)

Rozdział 11. Architektura i projekt modelu obsługi wyjątków (243)

• Wstęp (243)
  
• Dlaczego architekt powinien interesować się obsługą błędów? (244)
  
  • Koszt awarii (245)
  • Cena sukcesu (246)
• Architektura, projekt i rozwój (246)
  
  • Role architekta i projektanta: cienka linia na piasku (247)
  • Programista: na linii frontu (247)
• Kluczowe decyzje architektoniczne dotyczące modelu wyjątków (248)
  
  • Priorytety i cechy architektury (249)
• Cechy modelu wyjątków (250)
  
  • Strategia obsługi i propagacji wyjątków (250)
  • Model klas reprezentujących wyjątki i błędy (253)
  • Usługi uniwersalne (256)
• Podsumowanie (257)
  
  • Kilka słów na temat kolejnych rozdziałów (258)

Rozdział 12. Wzorce (259)

• Wstęp (259)
  
• Wzorce architektoniczne (oparta na wzorcach architektura oprogramowania, POSA-ASOP) (260)
  
  • 1. Wzorzec warstw (261)
  • 2. Model-widok-kontroler (MVC) (262)
• Wzorce projektowe "Bandy czworga" (264)
  
• Wzorce konstrukcyjne (264)
  
  • 1. Builder (budowniczy) (264)
  • 2. Singleton (266)
• Wzorce strukturalne (267)
  
  • 1. Adapter (267)
  • 2. Composite (268)
  • 3. Facade (fasada) (270)
  • 4. Proxy (pośrednik) (271)
• Wzorce czynnościowe (272)
  
  • 1. Chain of Responsibility (łańcuch odpowiedzialności) (272)
  • 2. Command (polecenie) (273)
  • 3. Observer (obserwator) (274)
  • 4. State (stan) (275)
  • 5. Strategy (strategia) (276)
• Wzorce projektowe J2EE (277)
  
• Warstwa integracyjna (278)
  
  • 1. Data Access Object, DAO (obiekt dostępu do danych) (278)
• Warstwa prezentacyjna (280)
  
  • 1. Front Controller (sterownik frontalny) (280)
  • 2. Intercepting Filter (wzorzec przechwytujący) (281)
• Warstwa biznesowa (282)
  
  • 1. Service Locator (lokalizator usług) (282)
  • 2. Session Facade (fasada sesji) (283)
• Podsumowanie (283)

Rozdział 13. Testowanie (285)

• Jaki jest cel testowania i dlaczego jest ono tak ważne? (285)
  
• Nieprawdziwe opinie na temat testowania (286)
  
  • Mit pierwszy: "Nie ma potrzeby, by programiści testowali swój kod" (287)
  • Mit drugi: "Programiści w pełni odpowiadają za poprawność kodu" (287)
  • Mit trzeci: "Do zweryfikowania aplikacji wystarczy <>" (288)
  • Mit czwarty: "Istnieje możliwość kompletnego przetestowania aplikacji" (288)
• Warianty testowania, czyli na zewnątrz i wewnątrz skrzynki (289)
  
  • Co znajduje się w skrzynce? (Typy testów) (289)
  • Podział ról i odpowiedzialności w procesie testowania (291)
• "Gdyby to było takie łatwe...", czyli problemy z testowaniem w Javie (293)
  
• Testowanie w praktyce (294)
  
  • W jaki sposób zinstytucjonalizować testowanie? (294)
  • Organizacja struktury testów (298)
• Taktyka i technologia, czyli jak zarządzać testami i jak je przeprowadzać (303)
  
  • Gotowe narzędzia obsługi testów (304)
  • Zintegrowane środowiska programistyczne (305)
  • Miara jakości aplikacji (306)
• Kiedy testy należy uznać za zakończone? (306)
  
  • Ogólna miara testowania (306)
  • Miara testowania stosowana przez programistów (307)

Rozdział 14. Usuwanie błędów (309)

• Wstęp (309)
  
• Zaczarowane słowo: błąd... (310)
  
• Zasady i praktyka debugowania (311)
  
• Strategie usuwania błędów (313)
  
• Widoczne wyniki oraz sposoby usuwania błędów (318)
  
  • Techniki testowania - poziom niski (320)
  • Techniki testowania - poziom średni (322)
  • Techniki testowania - poziom wysoki (323)
• Dodatkowe kwestie związane z usuwaniem błędów (325)
  
  • Debugowanie innych technologii (325)
  • Wyjątki zgłaszane na poziomie infrastruktury (326)

Dodatki (327)

Dodatek A Wpływ obsługi i deklarowania wyjątków na szybkość działania aplikacji (329)

Dodatek B Krótkie i łatwe wprowadzenie do JUnit (335)

Dodatek C MyBuggyServlet - kwestie poprawności komponentu (347)

Słownik używanych w książce terminów technicznych (349)

Bibliografia (353)

Skorowidz (357)