Systemy reaktywne. Wzorce projektowe i ich stosowanie - 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)