wprowadź własne kryteria wyszukiwania książek: (jak szukać?)
Twój koszyk:   0 zł   zamówienie wysyłkowe >>>
Strona główna > opis książki
English version
Książki:

polskie
podział tematyczny
 
anglojęzyczne
podział tematyczny
 
Newsletter:

Zamów informacje o nowościach z wybranego tematu
 
Informacje:

o księgarni

koszty wysyłki

kontakt

Cookies na stronie

 
Szukasz podpowiedzi?
Nie znasz tytułu?
Pomożemy Ci, napisz!


Podaj adres e-mail:


możesz też zadzwonić
+48 512 994 090

SYSTEMY REAKTYWNE WZORCE PROJEKTOWE I ICH STOSOWANIE


KUHN R. HANAFEE B. ALLEN J.

wydawnictwo: HELION, 2018, wydanie I

cena netto: 68.20 Twoja cena  64,79 zł + 5% vat - dodaj do koszyka

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


    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)


378 stron, Format: 17.0x23.3, oprawa miękka

Po otrzymaniu zamówienia poinformujemy pocztą e-mail lub telefonicznie,
czy wybrany tytuł polskojęzyczny lub anglojęzyczny jest aktualnie na półce księgarni.

 
Wszelkie prawa zastrzeżone PROPRESS sp. z o.o. www.bankowa.pl 2000-2018