Wstęp (9)

1. Widok z góry (19)

• Co to znaczy "enterprise?" (19)
  
• Powolny wzrost (21)
  
• Komponenty aplikacji (24)
  
  • Warstwa danych (24)
  • Warstwa aplikacyjna (26)
  • Warstwa cache'owania (29)
  • System komunikacyjny (32)
  • Serwer WWW (33)
  • Zapora sieciowa (33)

2. Wtyczki jako środek organizacji kodu (35)

• Korzyści (36)
  
• Tworzenie własnej wtyczki (37)
  
  • Rozszerzanie klas wbudowanych (38)
  • Rozszerzenia uniwersalne (40)
• Wdrażanie (45)
  
  • svn:externals (45)

3. Organizacja kodu za pomocą modułów (47)

• Pliki i katalogi (47)
  
• Granice modułu wyznaczają przestrzeń nazw (49)
  
  • Międzymodułowe skojarzenia klas modelowych (50)
  • Relacje wzajemne (51)
  • Modularyzacja jako wstęp do architektury usługowej (51)
  • Wymuszenie prawidłowej kolejności ładowania definicji klas (53)
• Ćwiczenia (54)
  
• Refaktoring (54)
  
  • Wyodrębnianie modułów fizycznych (54)
  • Uwalnianie metod użytkowych (55)

4. Baza danych jak forteca (57)

• Baza danych jako część aplikacji (58)
  
  • "Jedno środowisko wyznacza reguły" (58)
  • "Nasi programiści nie popełniają błędów" (58)
  • "Baza danych moja i tylko moja" (59)
• Siadając na ramionach gigantów (59)
  
  • Wybór właściwego systemu bazy danych (59)
  • A propos migracji (60)
  • Obalając mity... (62)
• Raporty, raporty... (63)

5. Budowanie solidnego modelu danych (67)

• Bilety do kina (67)
  
  • Na początek bardzo prosto (68)
  • Ograniczenia (70)
  • Obalamy mity (78)
  • Integralność referencyjna (78)
  • Wprowadzenie do indeksowania (85)

6. Refaktoryzacja bazy do trzeciej postaci normalnej (87)

• Trzecia postać normalna (87)
  
  • Zacznij od normalizacji (91)
• Dziedziczenie tabel i domieszki (92)
  
• Ćwiczenia (95)
  
• Refaktoryzacja (96)

7. Dane dziedzinowe (97)

• Kody pocztowe i geograficzne dane dziedzinowe (99)
  
• Wzorzec projektowy - strategia dla tabel dziedzinowych (101)
  
• Refaktoryzacja od samego początku (104)

8. Klucze złożone i postać normalna DKNF (107)

• Klucze naturalne - korzyści i kłopoty (108)
  
  • Wybór kluczy naturalnych (111)
• Siedząc już na ramionach giganta... (112)
  
  • Migracja do postaci normalnej DKNF (113)
  • Klucze wielokolumnowe i ich implementacja w Rails (116)
  • Odroczona kontrola integralności referencyjnej (120)
  • Coś za coś... (122)
• Ćwiczenia (123)
  
• Refaktoryzacja (124)
  
  • Klucz jednokolumnowy (124)
  • Klucz wielokolumnowy (125)

9. Wyzwalacze jako narzędzia kontroli skomplikowanych zależności wewnątrz danych (127)

• Kontrola ograniczeń za pomocą wyzwalaczy (127)
  
• Anatomia funkcji w języku PL/pgSQL (130)
  
  • To tylko łańcuchy... (131)
  • Zmienne lokalne i przypisywanie im wartości (131)
  • Bloki (132)
  • Dodatkowe cechy wyzwalacza (132)
  • Wyzwalacz - łagodna zapora lub bezpiecznik (132)
  • Instrukcje warunkowe (133)

10. Dziedziczenie wielotabelaryczne (135)

• O co chodzi? (135)
  
• Polimorfizm - co to jest? (137)
  
• Dziedziczenie a dane fizyczne (138)
  
  • Dziedziczenie jednotabelaryczne (140)
  • Dziedziczenie wielotabelaryczne (140)
  • Alternatywa wyłączająca dla zbioru kolumn (143)
  • Implementacja MTI w Rails (145)
• Klasy-fabryki (151)
  
• Ćwiczenia (152)
  
• Refaktoryzacja (152)
  
  • Z STI do MTI (152)
  • Z :polymorphic => true do MTI (153)

11. Modele widokowe (155)

• Widoki (156)
  
  • Definiowanie widoku (156)
• Definiowanie klasy modelowej na bazie widoku (157)
  
• Specyfika widoków (158)
  
  • Dodawanie, modyfikowanie i usuwanie rekordów (159)
  • Ograniczenia i klucze obce (159)
  • Indeksowanie (160)
• Ćwiczenia (161)
  
• Refaktoryzacja (161)

12. Widoki zmaterializowane (163)

• Reguły rządzące widokami zmaterializowanymi (164)
  
• Widok źródłowy (165)
  
  • Formatowanie widoku (166)
• Tabela docelowa (168)
  
• Funkcje odświeżające i unieważniające (169)
  
  • Zarządzanie zależnościami czasowymi (171)
  • Kto za to płaci? (172)
• Odświeżanie i unieważnianie sterowane wyzwalaczami (175)
  
  • Tabela movie_showtimes (176)
  • Tabela movies (178)
  • Tabela theatres (178)
  • Tabela orders (179)
  • Tabela purchased_tickets (180)
• Ukrycie implementacji dzięki widokowi uzgadniającemu (181)
  
  • Periodyczne odświeżanie (183)
• Indeksowanie widoku zmaterializowanego (184)
  
• To się naprawdę opłaca... (185)
  
• Kaskadowe cache'owanie widoków (186)
  
• Ćwiczenia (187)

13. SOA - zaczynamy (189)

• Czym jest SOA? (189)
  
• Dlaczego SOA? (192)
  
  • Współdzielenie zasobów (193)
  • Redukcja obciążenia baz danych (196)
  • Skalowalność i cache'owanie (202)
  • Lokalna redukcja złożoności (202)
• Podsumowanie (205)
  
• Ćwiczenia (205)

14. Specyfika SOA (207)

• Specyfika usług (207)
  
  • Ukryta implementacja (207)
  • Przystępne API (210)
• Projektowanie API (211)
  
  • Nie rozdrabniaj się (211)
  • Ogranicz kontakty (213)
  • Korzystaj ze współbieżności (214)
  • Tylko to - i nic więcej (215)
• REST, XML-RPC i SOAP (217)
  
  • XML-RPC (217)
  • SOAP (219)

15. Usługi typu XML-RPC (221)

• ActionWebService w Rails 2.0 (221)
  
• Definiowanie bariery abstrakcji (222)
  
  • ActiveRecord jako warstwa modelu fizycznego (222)
  • Warstwa modelu logicznego (224)
  • Definiowanie API (229)
• Więcej testów... (233)
  
• Wtyczka kliencka (235)
  
  • Współdzielony kod (236)
  • Kliencka klasa-singleton (237)
  • Testy integracyjne (238)

16. Przechodzimy na SOA (241)

• Usługa zamówień - OrdersService (242)
  
• Integracja z usługą MoviesService (252)
  
  • Konsekwencje... (254)
• Model obiektowy usługi MoviesService (256)
  
• Podsumowanie (265)

17. Usługi typu REST (267)

• Podstawy REST (267)
  
  • Zasoby i polecenia (267)
  • Sprzęt jest częścią aplikacji (269)
• REST a SOA (270)
  
  • REST a CRUD (270)
  • Uniwersalny interfejs (271)
  • HTTP+POX (273)
  • Definiowanie kontraktu usługi (274)
  • Klient REST w Rails (276)
  • REST czy XML-RPC? (276)

18. Usługi webowe typu RESTful (279)

• Sformułowanie zadania (279)
  
• Narzędzia (281)
  
  • ROXML (281)
  • Net::HTTP (283)
• Usługa MoviesWebService (284)
  
  • Implementacja zasobów serwera (284)
  • Implementacja akcji serwera (287)
  • Implementacja klienta (288)

19. Cache'owanie (295)

• Dla przypomnienia - cache'owanie w warstwie fizycznej (296)
  
  • Migawki (296)
  • Funkcja odświeżająca (297)
  • Wyzwalacze unieważniające (297)
  • Indeksowanie (298)
• Cache'owanie modeli logicznych (298)
  
  • Uwarunkowania (304)
  • Pułapka nieaktualnych danych (307)
  • Indeksowanie cache (310)
• Inne aspekty cache'owania (311)
  
  • Cache'owanie planu realizacji (311)
  • Cache'owanie żądań (312)
  • Cache'owanie w Rails (313)
  • Cache'owanie fragmentów, akcji i stron (314)

Skorowidz (315)

• Tytuł: Rails. Projektowanie systemów klasy enterprise
• Autor: Dan Chak
• Tytuł oryginału: Enterprise Rails
• Tłumaczenie: Andrzej Grażyński
• ISBN: 978-83-246-6027-8, 9788324660278
• Data wydania: 2012-09-25
• Format: Ebook
• Identyfikator pozycji: raprsy
• Wydawca: Helion