Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki

Systemy reaktywne. Wzorce projektowe i ich stosowanie Język: 1

978-83-283-3795-4

Cena Brutto: 67.00

Cena netto: 63.81

Ilość:
Wersja: Drukowana
Autor Roland Kuhn Dr., Brian Hanafee, Jamie Allen
Liczba_stron 368
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2018-02-10

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.


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.

Najważniejsze zagadnienia:

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

    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)

powrót
 
Produkty Podobne
Debugging Teams. Przez współpracę do lepszej produktywności
Nieoficjalny przewodnik konstruktora Lego Technic, wyd. II (TWARDA OPRAWA)
ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII
Czysta architektura. Struktura i design oprogramowania. Przewodnik dla profesjonalistów
JavaFX 9. Tworzenie graficznych interfejsów użytkownika
Python 3. Proste wprowadzenie do fascynującego świata programowania
Rozmowa kwalifikacyjna. O czym nie wiedzą kandydaci do pracy, czyli sekrety rekrutujących. Wydanie 4 rozszerzone
Ostra jazda. Za kulisami dążeń Ubera do dominacji na świecie
Skrypty powłoki systemu Linux. Receptury. Wydanie III
Zestaw 2 książek z serii Tajniki (C# i .NET Framework + ASP.NET Core 2.0)
Więcej produktów