Google App Engine Tworzenie wydajnych aplikacji w Javie

Google App Engine to idealny przykład usługi PaaS (ang. Platform as a Service). W tym modelu płaci się wyłącznie za wykorzystane zasoby dostawcy. Pozwala to na budowanie niezwykle elastycznych rozwiązań informatycznych. Jednak największą zaletą z perspektywy użytkownika tego rozwiązania jest brak konieczności utrzymywania własnej infrastruktury. Niezależnie od sytuacji, będziesz zawsze przygotowany na obsłużenie dowolnie dużego ruchu, a to naprawdę się opłaca!

Dzięki tej książce błyskawicznie rozpoczniesz przygodę z platformą Google App Engine. Autor pokaże Ci, jak szybko tworzyć złożone i wydajne aplikacje w chmurze Google. Zaprezentuje przełomowe techniki, pozwalające na skonstruowanie aplikacji, które są w stanie odpowiedzieć na żądanie w ciągu dwóch sekund przy tzw. zimnym uruchomieniu i w ciągu co najwyżej setek milisekund podczas normalnego działania w pozostałej części sesji.

W trakcie lektury dowiesz się, jak uniknąć najczęstszych błędów, które dramatycznie pogarszają wydajność i skalowalność aplikacji w chmurze, oraz poznasz najświeższe technologie do tworzenia interfejsów użytkownika. Proces powstawania aplikacji omówiony został od podstaw - od projektowania i modelowania danych, przez bezpieczeństwo i testowanie, aż po wdrożenie.

Po lekturze tej książki:

• swobodnie zainstalujesz aplikację na platformie Google App Engine
• skorzystasz z dodatkowych możliwości platformy
• będziesz przechowywać dane w Datastore’ach
• stworzysz w pełni bezpieczne rozwiązanie
• zagwarantujesz Twojej aplikacji najlepszą infrastrukturę!

Zagwarantuj najlepszą wydajność Twojej aplikacji w każdych warunkach.

Rozdziały:

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)