CZĘŚĆ I. PODSTAWY (9)

Rozdział 1. Java EE - naprawdę krótkie wprowadzenie (11)

• Web vs Enterprise (12)
• Serwery aplikacji (13)
• Streszczenie, czyli krótki przewodnik po niniejszej publikacji (13)
  • Serwlety - na dobry początek (13)
  • Deskryptor wdrożenia (14)
  • JSP - HTML + Java (15)
  • JPA - czas na dane! (15)
  • JSF - wyższy poziom prezentacji (16)
  • Facelets (16)

Rozdział 2. Pierwsza aplikacja webowa (17)

• Integrowanie Tomcata z Netbeansem (18)
• Pierwsza aplikacja (19)
• Dodawanie nowych elementów (21)
• Pierwszy serwlet? (23)

Rozdział 3. Serwlet - na dobry początek (27)

• Życie serwletu (27)
• Serwlet pod lupą (28)
• Żądanie - odpowiedź (29)
  • Przesyłanie odpowiedzi (31)
  • Om nom nom, czyli ciasteczka w pełnej krasie (33)
  • Sesje - nie tylko dla studentów (34)
• Konfiguracja w kodzie Javy - można tego uniknąć (36)
  • Parametry serwletów (36)
  • Kontekst serwletów (37)
• Trzech muszkieterów? (38)
  • Atrybuty a mnogość żądań (39)
• Słuchowisko (41)
  • ServletContextListener (42)
  • ServletContextAttributeListener (42)
  • ServletRequestAttributeListener i ServletRequestListener (42)
  • HttpSessionAttributeListener i HttpSessionListener (42)
  • HttpSessionBindingListener (43)
  • Sesja + wiele JVM = HttpSessionActivationListener (43)
• Filtry (44)
  • Techniczny aspekt filtrów (44)
  • Konfiguracja filtrów w pliku web.xml (45)
• Asynchroniczna obsługa żądań (46)

Rozdział 4. JSP - gdy out.println() nie wystarcza (49)

• Zacznijmy od początku, czyli JSP w świecie serwletów (50)
  • Pliki JSP dostępne bezpośrednio (50)
  • Pliki JSP wywoływane z poziomu serwletów (50)
• Pochodzenie JSP - małe dochodzenie (51)
• Pierwsze kroki w JSP (52)
  • Docenić wygodę, czyli jak to lat temu kilka bywało... (54)
• Expression Language - elegancja i wygoda (58)
  • Remedium - warto było czekać! (59)
  • Dostęp do obiektów w języku EL (60)
  • Beany, czyli ziarna - kult kawy wiecznie żywy (61)
  • Ziarna + EL = kolejne ułatwienie (62)
  • Ziarna, mapy i co dalej? (63)
  • EL - nie tylko atrybuty (64)
• Akcje JSP (65)
  • Include vs. Forward - odsłona druga (66)
  • Akcje + ziarna = kolejne potężne narzędzie (67)
  • Dynamiczne generowanie elementów (70)

Rozdział 5. JSTL - wisienka na torcie JSP (73)

• Skrzynka z narzędziami (73)
• Rdzeń (74)
  • c:out (74)
  • Ale to już było, czyli c:set (76)
  • Czwarty muszkieter (77)
  • Kontrola sterowania (77)
  • Pętelka do kompletu (79)
  • Wyjątki + JSP = ... (80)
• Adresy URL - same kłopoty (81)
  • Adresy URL bez tajemnic (81)
  • Tajemnica sesji... (82)
• Trzech tenorów (83)
• Na deser: funkcje! (84)
  • Przez kolekcje do serca (84)
  • Funkcje łańcuchowe (85)
• Podsumowanie (86)

CZĘŚĆ II. FRAMEWORKI WEBOWE (87)

Rozdział 6. JavaServer Faces (89)

• Frameworki - kolejny dowód na lenistwo człowieka (89)
• JSF - kanonu ciąg dalszy (90)
  • JSF, czyli MVC w praktyce (91)
  • Kontroler - uniwersalny spawacz (92)
• Małe zanurzenie (92)
  • Pierwsze przykłady (93)
• Aplikacja notowania giełdowe (94)
  • Tajemniczy zapis - # vs $ (99)
  • Notowania historyczne, czyli kolekcja w kolekcji (101)
  • Najpierw szablon, później treść (102)
  • Klient szablonu (103)
  • Przygotowania... (104)
  • Czas na obliczenia! (107)
  • Mały zastrzyk (109)
• JSF - komponenty, komponenty, komponenty! (110)
  • Output - (prawie) wszystko, czego do szczęścia potrzeba (111)
  • UIInput - teraz do szczęścia nie potrzeba już nic (112)
  • Powrót do szarej rzeczywistości... (116)
• Zasady działania JSF (119)
  • Przykładowa aplikacja - maszyna licząca (119)
  • Przywrócenie widoku (1) (122)
  • Pobranie danych z żądania (2) (123)
  • Walidacja (3) (123)
  • Aktualizacja wartości w modelu (ziarnach) (4) (123)
  • Wywołanie zadeklarowanych uprzednio metod (5) (124)
  • Renderowanie odpowiedzi (6) (124)
• Cykl życia w praktyce (124)
• Podsumowanie (125)

Rozdział 7. Konwertowanie i walidacja (127)

• Uroki transformacji (127)
  • Konwertery standardowe (128)
  • Piszemy konwerter! (130)
• Walidator - nieodłączny partner konwertera (134)
  • Walidatory - prawie jak konwertery (135)
  • Walidacja niestandardowa - więcej pracy (136)

CZĘŚĆ III. OBSŁUGA DANYCH (139)

Rozdział 8. JPA, czyli ORM + Java (141)

• Dostęp do danych w Javie (141)
  • Oświecenie (142)
• Pierwszy przykład (143)
  • Założenia (143)
  • Realizacja (143)
  • Tworzenie projektu (144)
  • Hibernate a JPA - co i jak w ORM-owym świecie (145)
  • Pierwsza klasa encji (145)
  • Jednostka utrwalania (149)
  • Graficzna strona aplikacji (150)
  • Dodawanie przychodni (154)
  • EntityManager i spółka... (156)
  • Menedżer encji - elegancki dostęp! = łatwa sprawa (157)
  • Nudni słuchacze - nareszcie przydatni! (160)
  • C już jest, czas na RUD (162)
  • Niewiele Ci mogę dać... (póki nie pozwolisz mi zaprezentować danych) (162)
  • Słuchacz akcji vs akcja - starcie numer 2 (164)
  • Istotny drobiazg - nasza aplikacja to niemowa! (166)

Rozdział 9. Związki między encjami - jedna tabela to za mało! (169)

• Przychodnia... i co dalej? (169)
  • Związki między tabelami - krótkie przypomnienie (169)
  • Związki SQL w praktyce (170)
  • Jeden do wielu, wiele do jednego (171)
  • Wiele do wielu - najwyższy stopień wtajemniczenia (171)
  • Dodajemy tabele do bazy (172)
• Encje klas Javy - czas na związki! (174)
  • Encja Przychodnia - zmiana na lepszy model (175)
  • Czas na nowości! (176)
  • Wizyta - encja JPA w pełnej krasie (183)
• CRUD dla lekarza - to już było, ale nie do końca (188)
  • Nowy lekarz - nowe pole, duża zmiana (188)
  • Magikonwersja (190)
  • Ziarnko do ziarnka i zbierze się aplikacja (191)
  • Kolejne metody ziarna LekarzBean... (193)
  • Na zakończenie - edycja (193)
  • Pacjenci - suplement (195)
• Danie główne: all in one, czyli wizyty! (197)
  • Od czegoś trzeba zacząć, czyli zmiany (197)
  • Dodawanie wizyty (200)
  • Ostatnie ziarno (202)
  • Edycja i usuwanie - powrót (204)
  • Koniec coraz bliżej, czyli edycja w pełnej krasie (205)
• Podsumowanie (206)

Rozdział 10. JPQL i jego możliwości (207)

• Prawie jak SQL... "prawie" robi różnicę (207)
• Podstawy (208)
  • Pobieranie z wariantami (208)
  • JPQL a atrybuty złożone i null (210)
  • Nieco więcej o SELECT (211)
  • Funkcje obliczeniowe (212)
  • Operacje niezwiązane z pobieraniem (213)
• Mechanizmy zaawansowane (213)
  • JOIN na lewo, JOIN na prawo... (214)
  • Grupowanie i sortowanie (215)
  • Podzapytania - prawdziwa moc (216)
• Podsumowanie (217)

Rozdział 11. Szybko, jeszcze szybciej, czyli WebSockets w akcji (219)

• Haki, haczyki i obejścia - jak to dawniej bywało (220)
  • Ramki (220)
  • AJAX (221)
  • Techniki zewnętrzne (222)
  • Comet (223)
• Zdarzenia wysyłane przez serwer (224)
• Gniazda webowe (ang. WebSockets) (224)
• Przykładowy projekt (225)
  • Założenia (225)
  • Obsługa gniazd webowych w Javie EE (230)
• Podsumowanie (234)

Rozdział 12. Wstrzykiwanie zależności i jego zastosowania (235)

• Wstrzykiwanie zależności a Java EE (237)
  • Konfiguracja aplikacji webowej w celu obsługi CDI (237)
  • Co daje nam CDI (238)

Rozdział 13. Integracja aplikacji webowej z mobilną na przykładzie JAX-RS (245)

• Przykładowa aplikacja (247)
  • Kod bez kodu, czyli konfiguracja wstępna (247)
  • Aplikacja mobilna (253)

DODATKI (263)

Dodatek A. Instalacja serwera Apache Tomcat (265)

• Pobranie (265)
• Konfiguracja (266)

Bibliografia (267)

Skorowidz (269)

• Tytuł: Java EE 6. Programowanie aplikacji WWW. Wydanie II
• Autor: Krzysztof Rychlicki-Kicior
• ISBN: 978-83-283-2006-2, 9788328320062
• Data wydania: 2015-09-04
• Format: Ebook
• Identyfikator pozycji: javee2
• Wydawca: Helion