Szczegóły ebooka

Systemy reaktywne. Wzorce projektowe i ich stosowanie

Systemy reaktywne. Wzorce projektowe i ich stosowanie

Roland Kuhn Dr., Brian Hanafee, Jamie Allen

Ebook

Systemy reaktywne. Wzorce projektowe i ich stosowanie

Uznane duże aplikacje internetowe, takie jak portale społecznościowe, systemy bankowe czy handlowe, działają szybko i niezawodnie. Muszą radzić sobie nawet wtedy, gdy ich niektóre części ulegną awarii. Nie mogą zawieść, gdy będzie z nich korzystać większa liczba użytkowników niż zwykle. Naturalnie, muszą być odporne na różne zagrożenia, a oprócz tego skalowalne i łatwe w rozbudowie. Tym i wielu innym wymaganiom odpowiadają systemy responsywne — które bez względu na okoliczności sprawnie przetwarzają dane wprowadzane przez użytkowników. Pomyślne wdrożenie systemu reaktywnego wymaga jednak nieco innego spojrzenia na tworzenie oprogramowania.

Jakie cechy wyrózniają system reaktywny? O tym mówi tzw. Manifest reaktywny i jego podstawowe 4 postulaty:

  • responsywność - system musi reagować na interakcje użytkowników,
  • niezawodność - system musi reagować na awarie i być dostępny non stop,
  • elastyczność - system musi reagować na zmieniające się obciążenie,
  • sterowanie za pomocą komunikatów - system musi reagować na wprowadzane dane.

Niniejsza książka jest wyczerpującym wprowadzeniem do implementacji systemów reaktywnych. Opisano tu filozofię programowania reaktywnego, zasady projektowania aplikacji, wzorce projektowe i ich zastosowanie. Szczegółowo wyjaśniono, jakie problemy można rozwiązywać w ten sposób, a podane przykłady opatrzono pełnymi kodami źródłowymi. Bazując na postulatach Manifestu reaktywnego, przedstawiono metodykę budowy architektury modułowej, zasady tworzenia komunikatów, które sterują tą architekturą, opisano też potrzebne narzędzia i sposób ich wykorzystania. Nie zabrakło informacji o dobrych praktykach programowania i testowaniu aplikacji.

Na pewno do lektury przyda Ci się znajomość podstawowych zagadnień programistycznych i pewne doświadczenie w pracy z systemami rozproszonymi.

Najważniejsze zagadnienia w książce:

  • manifest reaktywny i jego postulaty
  • hierarchia modułów i przepływy danych
  • programowanie funkcyjne i reaktywne
  • obsługa awarii
  • wzorce projektowe i ich stosowanie

Systemy reaktywne — odpowiedź na wyzwania naszych czasów!

Dr Roland Kuhn jest ekspertem w dziedzinie rozproszonych systemów obliczeniowych. Obronił doktorat w instytucie CERN w Szwajcarii. Później pracował dla Niemieckiej Agencji Kosmicznej. Obecnie tworzy systemy reaktywne.

Brian Hanafee jest głównym architektem systemów w Wells Fargo Bank. Wcześniej tworzył nowe produkty dla Oracle i pisał oprogramowanie do systemów wizyjnych montowanych w hełmach pilotów samolotów wojskowych.

Jamie Allen jest programistą i architektem oprogramowania. Pracuje jako dyrektor techniczny projektu platformy handlowej UCP w Starbucks. Od 2008 r. tworzy w języku Scala reaktywne aplikacje dla klientów na całym świecie.

Przedmowa (13)

Wstęp (15)

Podziękowania (17)

O książce (19)

O autorach (21)

CZĘŚĆ I. WPROWADZENIE (23)

Rozdział 1. System reaktywny? (25)

  • 1.1. Anatomia systemu reaktywnego (26)
  • 1.2. Problem obciążenia (28)
  • 1.3. Problem awarii (29)
  • 1.4. Tworzenie responsywnego systemu (30)
  • 1.5. Zapobieganie efektowi kuli błota (32)
  • 1.6. Integrowanie komponentów niereaktywnych (33)
  • 1.7. Podsumowanie (34)

Rozdział 2. Przegląd Manifestu reaktywnego (35)

  • 2.1. Reagowanie systemu na interakcje użytkowników (35)
    • 2.1.1. Podejście tradycyjne (36)
    • 2.1.2. Analiza czasu odpowiedzi współdzielonego zasobu (38)
    • 2.1.3. Ograniczanie maksymalnego czasu odpowiedzi za pomocą kolejki (39)
  • 2.2. Analiza paralelizmu (41)
    • 2.2.1. Skrócenie czasu odpowiedzi z wykorzystaniem paralelizmu (41)
    • 2.2.2. Usprawnianie paralelizmu za pomocą komponowanych futur (43)
    • 2.2.3. Cena szeregowej iluzji (44)
  • 2.3. Ograniczenia paralelizmu (46)
    • 2.3.1. Prawo Amdahla (46)
    • 2.3.2. Uniwersalne prawo skalowalności (47)
  • 2.4. Obsługa awarii (48)
    • 2.4.1. Rozczłonkowywanie i grodzenie (50)
    • 2.4.2. Bezpieczniki (51)
    • 2.4.3. Nadzorowanie usług (53)
  • 2.5. Utrata wysokiej spójności danych (54)
    • 2.5.1. ACID 2.0 (56)
    • 2.5.2. Odbieranie zmian (57)
  • 2.6. Wzorce projektowania reaktywnego (58)
    • 2.6.1. Zarządzanie złożonością oprogramowania (59)
    • 2.6.2. Przystosowanie modeli programistycznych do rzeczywistości (60)
  • 2.7. Podsumowanie (61)

Rozdział 3. Narzędzia (63)

  • 3.1. Pierwsze rozwiązania reaktywne (63)
  • 3.2. Programowanie funkcyjne (65)
    • 3.2.1. Niezmienność (66)
    • 3.2.2. Przejrzystość referencyjna (68)
    • 3.2.3. Efekty uboczne (69)
    • 3.2.4. Funkcje pierwszej klasy (70)
  • 3.3. Responsywność dla użytkowników (70)
    • 3.3.1. Ustalanie priorytetów cech wydajnościowych (71)
  • 3.4. Dostępne narzędzia reaktywne (72)
    • 3.4.1. Zielone wątki (72)
    • 3.4.2. Pętle zdarzeń (73)
    • 3.4.3. Język CSP (74)
    • 3.4.4. Futury i promesy (76)
    • 3.4.5. Rozszerzenia reaktywne (80)
    • 3.4.6. Model Aktor (82)
  • 3.5. Podsumowanie (86)

CZĘŚĆ II. FILOZOFIA REAKTYWNOŚCI W PIGUŁCE (87)

Rozdział 4. Przesyłanie komunikatów (89)

  • 4.1. Komunikaty (89)
  • 4.2. Pionowa skalowalność aplikacji (90)
  • 4.3. Sterowanie zdarzeniami i komunikatami (91)
  • 4.4. Synchroniczne i asynchroniczne przesyłanie komunikatów (93)
  • 4.5. Sterowanie przepływem danych (95)
  • 4.6. Gwarancja dostarczania komunikatów (97)
  • 4.7. Zdarzenia jako komunikaty (100)
  • 4.8. Synchroniczne przesyłanie komunikatów (101)
  • 4.9. Podsumowanie (102)

Rozdział 5. Przezroczystość lokalizacji (103)

  • 5.1. Czym jest przezroczystość lokalizacji? (103)
  • 5.2. Błędne wyobrażenia o przezroczystości wywołań (104)
  • 5.3. Ratunek w jawnym przesyłaniu komunikatów (105)
  • 5.4. Optymalizacja lokalnego przekazywania komunikatów (107)
  • 5.5. Utraty komunikatów (107)
  • 5.6. Pozioma skalowalność aplikacji (109)
  • 5.7. Przezroczystość lokalizacji upraszcza testy (110)
  • 5.8. Dynamiczne komponowanie systemu (111)
  • 5.9. Podsumowanie (112)

Rozdział 6. Dziel i rządź (113)

  • 6.1. Hierarchiczna struktura problemu (114)
    • 6.1.1. Tworzenie hierarchii modułów (114)
  • 6.2. Zależności i moduły pochodne (115)
    • 6.2.1. Zapobieganie powstawaniu matryc (116)
  • 6.3. Budowanie własnej ogromnej korporacji (118)
  • 6.4. Zalety precyzyjnej specyfikacji i testów (119)
  • 6.5. Skalowalność pozioma i pionowa aplikacji (120)
  • 6.6. Podsumowanie (121)

Rozdział 7. Strukturalna obsługa awarii (123)

  • 7.1. Własność oznacza zobowiązanie (123)
  • 7.2. Własność określa kontrolę cyklu życia modułu (125)
  • 7.3. Odporność na awarie na wszystkich poziomach (127)
  • 7.4. Podsumowanie (127)

Rozdział 8. Rozdzielona spójność danych (129)

  • 8.1. Ratunek w niezależnych modułach (130)
  • 8.2. Grupowanie danych i transakcji (131)
  • 8.3. Modelowanie przepływów danych ponad granicami transakcyjnymi (131)
  • 8.4. Jednostka awaryjności = jednostka spójności (133)
  • 8.5. Segregacja odpowiedzialności (133)
  • 8.6. Utrzymywanie odizolowanych zakresów spójności (135)
  • 8.7. Podsumowanie (136)

Rozdział 9. Niedeterminizm na życzenie (137)

  • 9.1. Programowanie logiczne i deklaratywny przepływ danych (137)
  • 9.2. Reaktywne programowanie funkcyjne (139)
  • 9.3. Współdzielenie niczego upraszcza równoległość operacji (140)
  • 9.4. Współdzielenie stanu i równoległość (141)
  • 9.5. Co zatem powinniśmy robić? (141)
  • 9.6. Podsumowanie (143)

Rozdział 10. Przepływ danych (145)

  • 10.1. Wysyłanie danych (145)
  • 10.2. Modelowanie procesów w domenie (147)
  • 10.3. Określanie ograniczeń odporności na awarie (147)
  • 10.4. Szacowanie ilości komunikatów i skali wdrożenia (148)
  • 10.5. Planowanie sterowania przepływami (149)
  • 10.6. Podsumowanie (149)

CZĘŚĆ III. WZORCE (151)

Rozdział 11. Testy aplikacji reaktywnych (153)

  • 11.1. Jak testować aplikacje? (153)
    • 11.1.1. Testy jednostkowe (154)
    • 11.1.2. Testy komponentów (155)
    • 11.1.3. Testy łańcuchowe (155)
    • 11.1.4. Testy integracyjne (155)
    • 11.1.5. Testy akceptacyjne (156)
    • 11.1.6. Testy czarnej i białej skrzynki (156)
  • 11.2. Środowisko testowe (157)
  • 11.3. Testy asynchroniczne (158)
    • 11.3.1. Blokujące odbiorniki komunikatów (159)
    • 11.3.2. Sztuka doboru czasu oczekiwania (161)
    • 11.3.3. Wykrywanie braku komunikatów (167)
    • 11.3.4. Tworzenie synchronicznych kodów wykonawczych (168)
    • 11.3.5. Asercje asynchroniczne (170)
    • 11.3.6. Testy w pełni asynchroniczne (170)
    • 11.3.7. Wykrywanie braku błędów asynchronicznych (173)
  • 11.4. Testowanie systemów niedeterministycznych (176)
    • 11.4.1. Problem z planowaniem wykonywania testów (176)
    • 11.4.2. Testowanie komponentów rozproszonych (176)
    • 11.4.3. Aktorzy imitacyjni (177)
    • 11.4.4. Komponenty rozproszone (179)
  • 11.5. Testowanie elastyczności systemu (179)
  • 11.6. Testowanie sprężystości systemu (179)
    • 11.6.1. Sprężystość aplikacji (180)
    • 11.6.2. Sprężystość infrastruktury (183)
  • 11.7. Testowanie responsywności systemu (185)
  • 11.8. Podsumowanie (186)

Rozdział 12. Wzorce uodporniania na awarie i odtwarzania systemu (187)

  • 12.1. Wzorzec Prosty Komponent (187)
    • 12.1.1. Opis problemu (188)
    • 12.1.2. Stosowanie wzorca (188)
    • 12.1.3. Weryfikacja wzorca (190)
    • 12.1.4. Kiedy stosować wzorzec? (191)
  • 12.2. Wzorzec Jądro Błędu (191)
    • 12.2.1. Opis problemu (191)
    • 12.2.2. Stosowanie wzorca (192)
    • 12.2.3. Weryfikacja wzorca (195)
    • 12.2.4. Kiedy stosować wzorzec? (196)
  • 12.3. Wzorzec Pozwól Na Awarię (196)
    • 12.3.1. Opis problemu (197)
    • 12.3.2. Stosowanie wzorca (197)
    • 12.3.3. Weryfikacja wzorca (198)
    • 12.3.4. Zagadnienia implementacyjne (199)
    • 12.3.5. Konkluzja: wzorzec Bicie Serca (200)
    • 12.3.6. Konkluzja: wzorzec Proaktywny Sygnał Awaryjny (201)
  • 12.4. Wzorzec Bezpiecznik (202)
    • 12.4.1. Opis problemu (202)
    • 12.4.2. Stosowanie wzorca (203)
    • 12.4.3. Weryfikacja wzorca (206)
    • 12.4.4. Kiedy stosować wzorzec? (207)
  • 12.5. Podsumowanie (207)

Rozdział 13. Wzorce replikacyjne (209)

  • 13.1. Wzorzec Replikacja Aktywna-Pasywna (209)
    • 13.1.1. Opis problemu (210)
    • 13.1.2. Stosowanie wzorca (211)
    • 13.1.3. Weryfikacja wzorca (220)
    • 13.1.4. Kiedy stosować wzorzec? (221)
  • 13.2. Wzorzec Replikacja Wielokrotna-Główna (221)
    • 13.2.1. Replikacja oparta na konsensusie (222)
    • 13.2.2. Replikacja z wykrywaniem i rozwiązywaniem konfliktów (225)
    • 13.2.3. Bezkonfliktowe typy replikowanych danych (226)
  • 13.3. Wzorzec Replikacja Aktywna-Aktywna (233)
    • 13.3.1. Opis problemu (234)
    • 13.3.2. Stosowanie wzorca (235)
    • 13.3.3. Weryfikacja wzorca (240)
    • 13.3.4. Odniesienie do wirtualnej synchroniczności (241)
  • 13.4. Podsumowanie (242)

Rozdział 14. Wzorce zarządzania zasobami (245)

  • 14.1. Wzorzec Enkapsulacja Zasobów (245)
    • 14.1.1. Opis problemu (246)
    • 14.1.2. Stosowanie wzorca (246)
    • 14.1.3. Weryfikacja wzorca (252)
    • 14.1.4. Kiedy stosować wzorzec? (253)
  • 14.2. Wzorzec Wypożyczenie Zasobu (253)
    • 14.2.1. Opis problemu (254)
    • 14.2.2. Stosowanie wzorca (254)
    • 14.2.3. Weryfikacja wzorca (256)
    • 14.2.4. Kiedy stosować wzorzec? (257)
    • 14.2.5. Zagadnienia implementacyjne (257)
    • 14.2.6. Wariant: zastosowanie wzorca Wypożyczenie Zasobu do częściowego udostępniania zasobu (258)
  • 14.3. Wzorzec Złożone Polecenie (258)
    • 14.3.1. Opis problemu (259)
    • 14.3.2. Stosowanie wzorca (260)
    • 14.3.3. Weryfikacja wzorca (267)
    • 14.3.4. Kiedy stosować wzorzec? (267)
  • 14.4. Wzorzec Pula Zasobów (268)
    • 14.4.1. Opis problemu (268)
    • 14.4.2. Stosowanie wzorca (269)
    • 14.4.3. Weryfikacja wzorca (271)
    • 14.4.4. Zagadnienia implementacyjne (272)
  • 14.5. Wzorzec Zarządzane Blokowanie (272)
    • 14.5.1. Opis problemu (273)
    • 14.5.2. Stosowanie wzorca (273)
    • 14.5.3. Weryfikacja wzorca (276)
    • 14.5.4. Kiedy stosować wzorzec? (277)
  • 14.6. Podsumowanie (277)

Rozdział 15. Wzorce przepływów komunikatów (279)

  • 15.1. Wzorzec Zapytanie-Odpowiedź (280)
    • 15.1.1. Opis problemu (280)
    • 15.1.2. Stosowanie wzorca (281)
    • 15.1.3. Popularne implementacje wzorca (282)
    • 15.1.4. Weryfikacja wzorca (287)
    • 15.1.5. Kiedy stosować wzorzec? (288)
  • 15.2. Wzorzec Samowystarczalny Komunikat (288)
    • 15.2.1. Opis problemu (289)
    • 15.2.2. Stosowanie wzorca (289)
    • 15.2.3. Weryfikacja wzorca (291)
    • 15.2.4. Kiedy stosować wzorzec? (292)
  • 15.3. Wzorzec Zapytaj (292)
    • 15.3.1. Opis problemu (293)
    • 15.3.2. Stosowanie wzorca (293)
    • 15.3.3. Weryfikacja wzorca (296)
    • 15.3.4. Kiedy stosować wzorzec? (297)
  • 15.4. Wzorzec Przekaż Przepływ (298)
    • 15.4.1. Opis problemu (298)
    • 15.4.2. Stosowanie wzorca (298)
    • 15.4.3. Weryfikacja wzorca (299)
    • 15.4.4. Kiedy stosować wzorzec? (299)
  • 15.5. Wzorzec Agregator (300)
    • 15.5.1. Opis problemu (300)
    • 15.5.2. Stosowanie wzorca (300)
    • 15.5.3. Weryfikacja wzorca (304)
    • 15.5.4. Kiedy stosować wzorzec? (304)
  • 15.6. Wzorzec Saga (304)
    • 15.6.1. Opis problemu (305)
    • 15.6.2. Stosowanie wzorca (306)
    • 15.6.3. Weryfikacja wzorca (307)
    • 15.6.4. Kiedy stosować wzorzec? (309)
  • 15.7. Wzorzec Biznesowy Uścisk Dłoni (lub Niezawodna Dostawa) (309)
    • 15.7.1. Opis problemu (310)
    • 15.7.2. Stosowanie wzorca (310)
    • 15.7.3. Weryfikacja wzorca (314)
    • 15.7.4. Kiedy stosować wzorzec? (315)
  • 15.8. Podsumowanie (315)

Rozdział 16. Wzorce sterowania przepływem komunikatów (317)

  • 16.1. Wzorzec Pobierz (317)
    • 16.1.1. Opis problemu (318)
    • 16.1.2. Stosowanie wzorca (318)
    • 16.1.3. Weryfikacja wzorca (320)
    • 16.1.4. Kiedy stosować wzorzec? (321)
  • 16.2. Wzorzec Zarządzana Kolejka (321)
    • 16.2.1. Opis problemu (322)
    • 16.2.2. Stosowanie wzorca (322)
    • 16.2.3. Weryfikacja wzorca (323)
    • 16.2.4. Kiedy stosować wzorzec? (324)
  • 16.3. Wzorzec Pomiń (324)
    • 16.3.1. Opis problemu (324)
    • 16.3.2. Stosowanie wzorca (325)
    • 16.3.3. Weryfikacja wzorca (327)
    • 16.3.4. Kiedy stosować wzorzec? (329)
  • 16.4. Wzorzec Dławik (330)
    • 16.4.1. Opis problemu (330)
    • 16.4.2. Stosowanie wzorca (330)
    • 16.4.3. Weryfikacja wzorca (333)
  • 16.5. Podsumowanie (333)

Rozdział 17. Wzorce zarządzania i zapisywania stanów (335)

  • 17.1. Wzorzec Obiekt Domenowy (336)
    • 17.1.1. Opis problemu (336)
    • 17.1.2. Stosowanie wzorca (336)
    • 17.1.3. Weryfikacja wzorca (339)
  • 17.2. Wzorzec Odłamkowanie (340)
    • 17.2.1. Opis problemu (340)
    • 17.2.2. Stosowanie wzorca (340)
    • 17.2.3. Weryfikacja wzorca (342)
    • 17.2.4. Ważna uwaga (342)
  • 17.3. Wzorzec Źródło Zdarzeń (343)
    • 17.3.1. Opis problemu (343)
    • 17.3.2. Stosowanie wzorca (343)
    • 17.3.3. Weryfikacja wzorca (345)
    • 17.3.4. Kiedy stosować wzorzec? (345)
  • 17.4. Wzorzec Strumień Zdarzeń (346)
    • 17.4.1. Opis problemu (347)
    • 17.4.2. Stosowanie wzorca (347)
    • 17.4.3. Weryfikacja wzorca (349)
    • 17.4.4. Kiedy stosować wzorzec? (349)
  • 17.5. Podsumowanie (350)

DODATKI

Dodatek A. Tworzenie diagramów systemów reaktywnych (353)

Dodatek B. Zilustrowany przykład (355)

  • B.1. Partycje geograficzne (355)
  • B.2. Planowanie przepływu informacji (357)
    • B.2.1. Krok 1.: odbieranie danych (358)
    • B.2.2. Krok 2.: przesyłanie danych do odpowiedniego węzła (358)
    • B.2.3. Krok 3.: relokacja i efektywne odczytywanie danych (359)
    • B.2.4. Bilans (362)
  • B.3. Co będzie w przypadku awarii? (362)
    • B.3.1. Awaria klienta (363)
    • B.3.2. Awaria łącza sieciowego (364)
    • B.3.3. Awaria węzła wejściowego dla danych (364)
    • B.3.4. Awaria łącza sieciowego między punktem wejścia danych a kwadratem mapy (364)
    • B.3.5. Awaria węzła z kwadratami mapy (365)
    • B.3.6. Awaria komponentu kwadratu sumarycznego (366)
    • B.3.7. Awaria łącza pomiędzy kwadratami mapy (366)
    • B.3.8. Awaria węzła z widokami map (366)
    • B.3.9. Podsumowanie obsługi awarii (366)
  • B.4. Czego nauczyliśmy się z tego przykładu? (367)
  • B.5. Co dalej? (368)

Dodatek C. Manifest reaktywny (369)

  • C.1. Główna treść (369)
  • C.2. Glosariusz (371)
    • C.2.1. Asynchronizm (371)
    • C.2.2. Ciśnienie wsteczne (371)
    • C.2.3. Przetwarzanie wsadowe (371)
    • C.2.4. Komponent (372)
    • C.2.5. Delegowanie (372)
    • C.2.6. Elastyczność (372)
    • C.2.7. Awaria (373)
    • C.2.8. Izolacja (373)
    • C.2.9. Przezroczystość lokalizacji (374)
    • C.2.10. Sterowanie komunikatami (374)
    • C.2.11. Algorytm nieblokujący (375)
    • C.2.12. Protokół (375)
    • C.2.13. Replikacja (375)
    • C.2.14. Zasób (375)
    • C.2.15. Skalowalność (376)
    • C.2.16. System (376)
    • C.2.17. Użytkownik (376)

Skorowidz (377)

  • Tytuł: Systemy reaktywne. Wzorce projektowe i ich stosowanie
  • Autor: Roland Kuhn Dr., Brian Hanafee, Jamie Allen
  • Tytuł oryginału: Reactive Design Patterns
  • Tłumaczenie: Andrzej Watrak
  • ISBN: 978-83-283-3796-1, 9788328337961
  • Data wydania: 2018-02-12
  • Format: Ebook
  • Identyfikator pozycji: sysrea
  • Wydawca: Helion