Wprowadzenie (13)

Podziękowania (21)

O autorze (23)

I Wprowadzenie do App Engine (25)

1. Konfiguracja środowiska (27)

• Praca z Eclipse (27)
  
  • Instalacja wtyczek Eclipse (28)
  • Utworzenie nowego projektu App Engine (31)
  • Uruchomienie serwera roboczego (33)
  • Wdrożenie aplikacji na serwerach Google (36)
• Wdrażanie z linii poleceń (39)
  
  • Uruchamianie serwera roboczego z linii poleceń (40)
  • Wdrażanie aplikacji App Engine z linii poleceń (40)
• Podsumowanie (40)

2. Wydajność w środowisku App Engine (41)

• Wydajność w chmurze (41)
  
  • Porównanie App Engine z tradycyjnymi aplikacjami internetowymi (42)
  • Optymalizacja kosztów zasobów (42)
• Pomiar kosztów ładowania klas (42)
  
  • Czas uruchomienia serwletu zawierającego zewnętrzną bibliotekę (43)
  • Czas uruchomienia serwletu niezawierającego zewnętrznej biblioteki (44)
  • Zmniejszenie objętości pliku web.xml (45)
• Unikanie zimnych uruchomień (47)
  
  • Rezerwacja stale czynnych instancji (47)
  • Wstępne ładowanie klas przy użyciu żądań rozgrzewających (48)
  • Obsługa współbieżnych żądań w sposób bezpieczny dla wątków (48)
  • Obsługa żądań wymagających dużej ilości pamięci za pomocą instancji typu backend (48)
• Ogólna poprawa wydajności (49)
  
  • Optymalizacja modelu danych pod kątem wydajności (49)
  • Unikanie nadmiarowych obliczeń przy użyciu cache (49)
  • Odraczanie długotrwałych zadań za pomocą kolejki zadań (49)
  • Poprawa szybkości ładowania stron w przeglądarce (50)
  • Asynchroniczne API (50)
  • Optymalizacja aplikacji przed jej wdrożeniem (50)
• Podsumowanie (51)

II Podstawy projektowania aplikacji (53)

3. Anatomia aplikacji Google App Engine (55)

• Przesyłanie plików w celu wykonania dynamicznego wdrożenia (55)
  
• Struktura katalogów (56)
  
  • Ustawianie parametrów wdrożenia (58)
  • Uruchamianie zadań okresowych (61)
  • Określenie indeksów w magazynie danych (61)
  • Blokowanie zakresów IP (62)
  • Konfiguracja poziomów logowania (63)
  • Konfiguracja kolejek zadań (63)
  • Zabezpieczanie URL (63)
• Konfiguracja panelu administracyjnego (64)
  
  • Podstawy aplikacji (65)
  • Aktualna wersja (65)
  • Dodawanie użytkowników (66)
  • Naliczanie opłat (67)
• Podsumowanie (67)

4. Modelowanie danych na potrzeby magazynu Google App Engine Datastore (69)

• Odwrót od relacyjnych magazynów danych (69)
  
  • Denormalizacja danych (70)
  • Agregacja danych bez złączeń (70)
  • Projektowanie danych bezschematowych (71)
• Modelowanie danych (71)
  
  • Projektowanie na poziomie mikro (71)
  • Wybór właściwości (73)
  • Rozdzielenie encji (73)
  • Tworzenie i utrzymywanie relacji pomiędzy encjami (74)
  • Relacje jeden do wielu i wiele do wielu (75)
• Praca z danymi (76)
  
  • Transakcje (76)
  • Zapytania (77)
  • Tworzenie indeksów (78)
  • Aktualizacja wersji aplikacji korzystającej z Datastore (78)
• Podsumowanie (79)

5. Projektowanie aplikacji (81)

• Zbieranie wymagań (81)
  
• Wybór zestawu narzędzi (82)
  
  • Wybór frameworku (82)
  • Wybór systemu szablonów (84)
  • Wybór bibliotek (85)
• Decyzje projektowe (86)
  
  • Modelowanie danych (86)
  • Modelowanie adresów URL (88)
  • Przechodzenie pomiędzy stronami (89)
• Podsumowanie (89)

III Podstawy projektowania interfejsu użytkownika (91)

6. Tworzenie interfejsu użytkownika w HTML5 (93)

• Powitajmy HTML5 (93)
  
• Stosowanie nowych znaczników HTML5 (94)
  
• Rysowanie po płótnie (96)
  
• Przeciąganie i upuszczanie na stronach (97)
  
• Ciekawe elementy formularzy (99)
  
• Wykrywanie lokalizacji użytkownika (100)
  
• Przechowywanie danych po stronie klienta (101)
  
  • Przechowywanie danych pomiędzy sesjami (102)
  • Przechowywanie danych sesyjnych (103)
  • Odpytywanie ustrukturyzowanych danych z wykorzystaniem lokalnej bazy danych SQL (104)
• Podsumowanie (106)

7. Modyfikacja układu strony za pomocą CSS (107)

• Wskazywanie elementów za pomocą CSS3 (107)
  
  • Obliczanie szczegółowości (108)
  • Identyfikatory (108)
  • Wskazywanie klas (110)
  • Wskazywanie pseudoklas (110)
  • Wskazywanie atrybutów (111)
  • Wskazywanie elementów (112)
  • Wskazywanie pseudoelementów (112)
• Nowe efekty graficzne CSS3 (113)
  
  • Zaokrąglone krawędzie (115)
  • Animacje 2D (116)
  • Animacje 3D (118)
• Podsumowanie (119)

8. Statyczna interakcja z wykorzystaniem kodu JavaScript (121)

• Uproszczony przykład (121)
  
• Uporządkowanie kodu HTML dzięki zastosowaniu dyskretnego JavaScriptu (124)
  
• Zmniejszenie zależności od JavaScriptu poprzez stopniowe rozszerzanie HTML-a (128)
  
• Optymalizacja wydajności za pomocą delegacji zdarzeń (130)
  
• Unikanie zmiennych globalnych (132)
  
• Podsumowanie (134)

9. Dynamiczna interakcja z wykorzystaniem technologii AJAX (135)

• AJAX na sposób klasyczny, bez frameworków (135)
  
  • Komunikacja z serwerem za pomocą XML-a (136)
  • Komunikacja z serwerem za pomocą formatu JSON (138)
  • Komunikacja z serwerem za pomocą HTML-a (140)
• Google App Engine Channel API (141)
  
  • Otwarcie kanału przez serwer (142)
  • Obsługa komunikatów po stronie klienta (144)
• Podsumowanie (146)

IV Korzystanie z popularnych API App Engine (147)

10. Składowanie danych w magazynach Datastore i Blobstore (149)

• Synchroniczne przetwarzanie danych (149)
  
  • Synchroniczne składowanie danych (150)
  • Synchroniczne odpytywanie danych (153)
  • Synchroniczne pobieranie danych (154)
• Asynchroniczne przetwarzanie danych (156)
  
  • Asynchroniczne składowanie danych (156)
  • Asynchroniczne odpytywanie danych (158)
  • Asynchroniczne pobieranie danych (159)
• Ustanawianie transakcji (160)
  
  • Wieloorganizacyjność i przestrzenie nazw (162)
• Składowanie i pobieranie dużych plików (164)
  
  • Składowanie dużych plików w Blobstore (164)
  • Odpytywanie Blobstore (166)
  • Pobieranie plików z Blobstore (168)
• Wysyłanie dużej ilości danych za pomocą Remote API (169)
  
• Podsumowanie (170)

11. Wysyłanie i odbieranie poczty elektronicznej (173)

• Wysyłanie rozbudowanych wiadomości e-mail ze znacznikami HTML i załącznikami (173)
  
  • Parametryzacja ciała wiadomości (176)
  • Zabezpieczenie serwletu (176)
  • Logowanie wysłanych wiadomości na serwerze roboczym (177)
  • Alternatywa - JavaMail API (177)
  • Porównanie API niskopoziomowego z JavaMail (178)
• Odbieranie poczty (179)
  
  • Konfiguracja serwletu odbierającego pocztę (179)
  • Zapisywanie odebranej poczty przez serwlet (180)
  • Odbieranie poczty elektronicznej bez JavaMail API (182)
  • Błędy (184)
• Uwzględnienie wydajności oraz quoty (184)
  
  • Ile trwa wysłanie wiadomości e-mail? (184)
  • Jaki jest koszt zimnego uruchomienia? (185)
  • Czy odbieranie poczty jest wydajne? (186)
• Podsumowanie (186)

12. Wykonywanie zadań w tle za pomocą Task Queue API oraz cron (187)

• Kolejkowanie zadań (187)
  
  • Kolejkowanie wysyłania poczty (188)
  • Konfiguracja kolejek (189)
  • Kontrola limitów (190)
  • Dodatkowe opcje (191)
  • Jak najlepiej wykorzystać kolejki zadań? (194)
• Planowanie zadań za pomocą cron (195)
  
  • Konfiguracja zadań za pomocą cron.xml (195)
  • Jak najlepiej wykorzystać zadania cron? (197)
• Odczyt nagłówków HTTP (197)
  
• Podsumowanie (199)

13. Przetwarzanie obrazów z wykorzystaniem usługi App Engine Image Service (201)

• Oszczędne stosowanie Image API (201)
  
• Odczyt i zapis obrazów (202)
  
  • Odczyt danych wprowadzonych przez użytkownika (202)
  • Zapis w magazynie danych (204)
  • Odczyt z magazynu danych (205)
  • Zwrócenie obrazu użytkownikowi (206)
  • Odczyt z pliku (207)
• Proste przekształcenia (208)
  
  • Tworzenie miniatur (208)
  • Przycinanie obrazów (210)
  • Obracanie obrazów (211)
  • Przerzucanie obrazów (211)
• Zaawansowane przekształcenia (211)
  
• Podsumowanie (214)

14. Optymalizacja wydajności za pomocą pamięci podręcznej cache (215)

• Podstawowe zastosowanie API memcache (215)
  
  • Na co uważać, stosując pamięć cache? (215)
  • Pamięć cache i wartości typu String (216)
• Strategia obsługi cache (218)
  
  • Redukcja obciążenia App Engine przy użyciu nagłówków ETag (218)
• Drobnoziarnista pamięć cache (220)
  
  • Implementacja interfejsu Serializable (221)
  • Umieszczanie w cache obiektów w postaci surowej (222)
• Zarządzanie cache (222)
  
  • Unieważnianie elementów w pamięci cache (223)
  • Opróżnianie cache (224)
• Inne metody przydatne podczas korzystania z cache (225)
  
  • Wkładanie i wyjmowanie wielu wartości (225)
  • Rejestracja metod obsługi błędów (225)
  • Inkrementacja wartości (225)
• JSR 107 jako alternatywa dla Memcache Service (226)
  
• Podsumowanie (226)

15. Pobieranie danych z zewnątrz za pomocą URL Fetch (227)

• Pobieranie danych z URL za pomocą żądań GET (227)
  
  • Wykorzystanie standardowego URL Fetch API (228)
  • Wykorzystanie niskopoziomowego URL Fetch API (229)
• Odczyt wyników (230)
  
  • Interpretacja wyników (230)
  • Zapis do memcache (230)
  • Zapis do magazynu danych (231)
• Dodatkowe opcje URL Fetch (231)
  
  • Kontrola czasu wygaśnięcia (231)
  • Elegancka obsługa wyjątków (233)
• Wysyłanie danych z formularza (234)
  
• Asynchroniczne pobieranie danych (235)
  
• Konsumpcja usług sieciowych (237)
  
  • Usługi REST (237)
  • Komunikacja z SOAP (238)
• Bezpieczeństwo (238)
  
  • HTTPS (238)
  • Otwarte porty (238)
• Podsumowanie (239)

16. Zabezpieczanie aplikacji internetowych za pomocą kont Google, OpenID i OAuth (241)

• Uwierzytelnianie użytkowników w oparciu o konta Google (241)
  
• Uwierzytelnianie użytkowników za pomocą OpenID (244)
  
• Dostęp z zewnątrz za pomocą OAuth (246)
  
• Zabezpieczanie adresów URL w web.xml (248)
  
  • Wymuszenie uwierzytelnienia (248)
  • Wymuszenie bezpiecznych protokołów (249)
• Zagadnienia związane z bezpieczeństwem (249)
  
  • Walidacja danych wejściowych (250)
  • Konfiguracja wieloorganizacyjności (250)
  • Przechowywanie danych osobowych (250)
• Podsumowanie (251)

17. Wysyłanie i odbieranie wiadomości za pomocą XMPP (253)

• Wysyłanie komunikatów XMPP (253)
  
• Odbieranie komunikatów XMPP (255)
  
• Odbieranie powiadomień o subskrypcji (257)
  
• Odbieranie powiadomień o obecności (260)
  
• Podsumowanie (262)

V Wdrażanie aplikacji (263)

18. Usprawnienie procesu wytwarzania aplikacji (265)

• Optymalizacja procesu wytwarzania aplikacji internetowych (265)
  
• Wejście w skórę kierownika projektu (266)
  
• Mniej prac pobocznych (266)
  
  • Wyznaczenie ostatecznego celu (266)
  • Rezygnacja ze zbędnych czynności (267)
• Rozszerzanie funkcjonalności (269)
  
  • Określenie priorytetów (269)
  • Planowanie iteracji (269)
  • Programowanie sterowane eksperymentem (270)
  • Stopniowe wprowadzanie zmian (271)
• Mierzenie jakości (271)
  
• Optymalizacja produktywności programistów (271)
  
  • Rytuały (272)
  • Nowe języki programowania (272)
  • Zarządzanie czasem i otoczeniem (272)
• Podsumowanie (273)

19. Zapewnienie jakości za pomocą narzędzi pomiarowych (275)

• Testowanie w środowisku produkcyjnym (275)
  
  • Racjonalna ocena wartości dodanej testów (276)
  • Testowanie zdroworozsądkowe (276)
  • Minimalizacja kosztów awarii (276)
• Inne podejście do użyteczności (277)
  
  • Funkcjonalność przed wyglądem (277)
  • Optymalizacja użyteczności w oparciu o wyniki profilowania i analizy statystyk (278)
• Sprawdzanie dostępności za pomocą Capabilities API (278)
  
• Logowanie nieoczekiwanych zachowań (280)
  
• Ciągłe profilowanie w środowisku produkcyjnym (282)
  
• Badanie reakcji użytkownika na Twój interfejs (285)
  
• Podsumowanie (287)

20. Sprzedaż aplikacji (289)

• Jak podejść do kwestii sprzedaży? (289)
  
• Znajomość odbiorcy (290)
  
• Dotarcie do odbiorcy (290)
  
  • Wiadomość w serwisie informacyjnym (290)
  • Pisanie artykułów (291)
  • Blogowanie (291)
  • Twitter (291)
  • Strony na Facebooku (293)
  • Aplikacje na Facebooku (294)
  • Reklamy w Google Apps Marketplace (295)
  • AdWords (296)
  • Optymalizacja aplikacji na potrzeby wyszukiwarek (297)
  • Zakładki społecznościowe (298)
  • Inne sklepy z aplikacjami mobilnymi (298)
• Zamiana klientów potencjalnych w aktualnych (299)
  
• Obsługa procesu płatności (299)
  
• Podsumowanie (300)

Skorowidz (301)

• Titel: Google App Engine. Tworzenie wydajnych aplikacji w Javie
• Autor: Adriaan de Jonge
• Originaler Titel: Essential App Engine: Building High-Performance Java Apps with Google App Engine
• Übersetzung: Justyna Walkowska
• ISBN: 978-83-246-6459-7, 9788324664597
• Veröffentlichungsdatum: 2012-12-21
• Format: E-book
• Artikelkennung: gooaej
• Verleger: Helion