Java Projektowanie aplikacji WWW

Aplikacje WWW w języku Java!

Język Java zadebiutował na rynku blisko dwadzieścia lat temu. Od tego czasu zdobył ogromną popularność i jest z powodzeniem używany do tworzenia projektów o różnym stopniu trudności. Język ten sprawdza się idealnie zarówno przy budowie zaawansowanych systemów bankowych, jak i prostych stron WWW. Przekonaj się, jaki potencjał kryje się w Javie!

Jeśli sięgniesz po tę książkę, błyskawicznie nauczysz się budować strony WWW przy użyciu serwletów i stron JSP. W kolejnych rozdziałach poznasz bardziej zaawansowane narzędzia - szkielet Struts 2, Spring Web MVC oraz JSF 2. Podczas tworzenia aplikacji działających w środowisku wirtualnej maszyny języka Java nie jesteś skazany wyłącznie na ten język. Wiele problemów możesz rozwiązać sprawniej za pomocą języków Scala lub Groovy. Książka ta jest doskonałą lekturą dla wszystkich osób chcących stworzyć stronę WWW w Javie i nie tylko!

Dzięki tej książce:
• skonfigurujesz swoje środowisko pracy
• poznasz aktualne trendy w tworzeniu aplikacji
• poznasz popularne szkielety do tworzenia aplikacji WWW
• sprawdzisz możliwości języków Java, Groovy i Scala
• zbudujesz swoją stronę WWW

Przewodnik po świecie WWW w języku Java.

Spis treści:

Rozdział 1. Wprowadzenie do projektowania stron WWW w języku Java (17)

• Języki JVM (18)
  • Języki zaprojektowane dla JVM (18)
  • Języki zaimportowane do JVM (19)
• Java EE (19)
  • Platforma Java EE (20)
  • Poziom klienta (21)
  • Poziom sieciowy (21)
• Frameworki WWW Javy (25)
• Pierwsze kroki w Javie (25)
  • Konfiguracja środowiska programistycznego (26)
  • Tworzenie i uruchamianie pierwszej aplikacji Java (26)
  • Uruchamianie aplikacji Java (27)
  • Projektowanie aplikacji Java z wykorzystaniem środowiska IDE (27)
• Aplikacja typu księgarnia (32)
• Model danych dla aplikacji księgarni (32)
  • Warstwa dostępu do danych dla aplikacji typu księgarnia (36)
  • Klient dla warstwy dostępu do danych (43)
• Trendy i technologie w krajobrazie aplikacji sieciowych Java (45)
  • Responsywne aplikacje sieciowe (45)
  • Jednostronicowe aplikacje sieciowe (48)
  • Aplikacje sieciowe czasu rzeczywistego (48)
  • Reaktywne aplikacje sieciowe (48)
  • Mashupy i usługi sieciowe (49)
  • Semantic Web (Web 3.0) (50)
• Podsumowanie (51)

Rozdział 2. Budowanie aplikacji sieciowych za pomocą serwletów i stron JSP (53)

• Serwlety (55)
  • Pierwsza aplikacja sieciowa z wykorzystaniem serwletu (56)
  • Obiekty ServletContext i ServletConfig (67)
  • Interfejs RequestDispatcher (68)
  • Filtry (69)
  • Konfigurowanie serwletu za pomocą adnotacji (70)
• Technologia Java Server Pages (74)
  • Pierwsza aplikacja sieciowa z wykorzystaniem JSP (74)
  • Podstawy JSP (77)
• Wzorzec MVC (86)
• Aplikacja typu księgarnia (87)
  • Strona główna (88)
  • Wyświetlanie listy wszystkich książek (92)
  • Wyszukiwanie książek według kategorii (94)
  • Wyszukiwanie książek według słów kluczowych (96)
• Podsumowanie (100)

Rozdział 3. Najlepsze praktyki projektowania stron WWW na platformie Java EE (101)

• Najlepsze rozwiązania praktyczne: korzystanie z języka wyrażeń EL i biblioteki JSTL (102)
  • Język wyrażeń EL (104)
  • Biblioteka JSTL (120)
• Najlepsze rozwiązania praktyczne: używanie wzorców (135)
  • Filtr Przechwytujący (136)
  • Kontroler Frontowy (138)
  • Pomocnik Widoku (139)
  • Widok Kompozytowy (140)
  • Widok Dyspozytora (141)
  • Usługa Dla Pracownika (142)
• Frameworki WWW Javy (144)
  • Dlaczego warto korzystać z frameworku? (145)
• Podsumowanie (146)

Rozdział 4. Budowanie aplikacji sieciowej za pomocą frameworku Struts 2 (147)

• Przegląd frameworku Struts 2 (147)
• Akcja (150)
  • Interfejs Action (150)
  • Klasa ActionSupport (151)
• Interceptory (152)
• Obiekt ValueStack oraz język OGNL (153)
• Typ rezultatu i rezultat (153)
• Struts 2 znaczniki (154)
• Pierwsze kroki z frameworkiem Struts 2 (154)
• Aplikacja sieciowa typu księgarnia (165)
  • Funkcja logowania (166)
  • Tworzenie szablonów (170)
  • Integracja warstwy dostępu do danych (176)
• Podsumowanie (181)

Rozdział 5. Budowanie aplikacji sieciowych Java za pomocą frameworku Spring Web MVC (183)

• Przegląd frameworku Spring (184)
  • Programowanie aspektowe i instrumentacja (184)
  • Kontener podstawowy (184)
  • Dostęp do danych/integracja danych (185)
  • Testowanie (185)
  • Sieć (185)
• Podstawy frameworku Spring (186)
  • Kontekst aplikacji (190)
• Główne cele frameworku Spring (191)
  • Obsługa ścisłych powiązań za pomocą wstrzykiwania zależności (191)
  • Rozwiązywanie problemów związanych z krzyżowaniem się zagadnień za pomocą programowania aspektowego (195)
  • Usuwanie kodu dodatkowego za pomocą szablonów (199)
• Budowanie aplikacji sieciowej za pomocą modułu Web MVC frameworku Spring (203)
  • Architektura frameworku Spring Web MVC (203)
  • Pierwsze kroki z aplikacją sieciową frameworku Spring Web MVC (208)
  • Wdrażanie frameworku Spring Web MVC w aplikacji typu księgarnia (218)
  • Praca z formularzami z wykorzystaniem adnotacji (223)
  • Walidacja oparta na adnotacjach (228)
• Podsumowanie (231)

Rozdział 6. Wykorzystanie frameworku JSF 2 do projektowania stron WWW opartych na komponentach (233)

• Architektura frameworku JSF (234)
  • Kontroler FacesServlet (234)
  • Ziarna zarządzalne (234)
  • Język VDL (234)
  • Język wyrażeń EL frameworku JSF (235)
  • Biblioteka znaczników frameworku JSF (235)
  • Komponent interfejsu użytkownika (235)
  • Renderer (236)
  • Konwerter i walidator (236)
  • Zdarzenia i nasłuchiwacze zdarzeń (236)
• Pierwsze kroki z frameworkiem JSF (237)
• Cykl życia aplikacji frameworku JSF (244)
  • Faza 1. Przywracanie widoku (245)
  • Faza 2. Zastosowanie wartości żądania (245)
  • Faza 3. Przetwarzanie walidacji (245)
  • Faza 4. Aktualizacja modelu (246)
  • Faza 5. Wywołanie aplikacji (246)
  • Faza 6. Renderowanie odpowiedzi (246)
• Ziarna zarządzalne (247)
• System Facelets (248)
  • Obsługa szablonów z systemem Facelets (248)
• Budowanie aplikacji typu księgarnia za pomocą frameworku JSF 2 (253)
  • Integracja frameworku JSF z frameworkiem Spring (254)
  • Uzyskiwanie dostępu do bazy danych z warstwy sieciowej poprzez szablon JDBCTemplate frameworku Spring (256)
  • Projektowanie szablonów (258)
  • Projektowanie interfejsu użytkownika za pomocą komponentów interfejsu użytkownika i języka wyrażeń EL frameworku JSF (258)
• Podsumowanie (261)

Rozdział 7. Szybkie projektowanie stron WWW za pomocą frameworku Grails (263)

• Właściwości frameworku Grails (263)
  • Konwencja ponad konfiguracją (264)
  • Rusztowanie (264)
  • Mapowanie obiektowo-relacyjne (264)
  • Wtyczki (265)
  • Testy jednostkowe (265)
  • Zintegrowany open source (265)
• Instalacja frameworku Grails (266)
• Aplikacja Hello World (266)
• Aplikacja typu księgarnia (267)
  • Tworzenie aplikacji typu księgarnia (268)
  • Uruchamianie aplikacji (272)
  • Tworzenie kontrolera (273)
  • Testowanie kontrolera (276)
  • Tworzenie klasy domeny (278)
• Rusztowanie (280)
  • Rusztowanie dynamiczne (281)
  • Rusztowanie statyczne (284)
• Konsola bazy danych H2 (297)
• Tworzenie relacji domenowych (298)
• Podsumowanie (303)

Rozdział 8. Framework Play z językami Java i Scala (305)

• Cechy frameworku Play 2 (305)
• Architektura MVC we frameworku Play 2 (306)
  • Router (307)
  • Kontroler (307)
  • Model (307)
  • Widok (308)
• Pierwsze kroki z frameworkiem Play (308)
  • Aplikacja helloworld w języku Java utworzona za pomocą frameworku Play (309)
  • Aplikacja helloworld języka Scala utworzona za pomocą frameworku Play 2 (317)
• Podstawowa aplikacja Java typu CRUD frameworku Play 2 (320)
  • Definiowanie tras (320)
  • Tworzenia kontrolera i akcji (320)
  • Tworzenie modelu (321)
  • Formularz i szablon widoku (322)
  • Uzyskiwanie dostępu do bazy danych (325)
  • Usuwanie książek (327)
• Podsumowanie (327)

Dodatek A. Wprowadzenie do języka Java (329)

• Klasy i obiekty (329)
• Zmienne (330)
  • Członkowie instancji (330)
  • Członkowie statyczni (331)
• Przeciążanie metody (331)
• Tablice (332)
• Konstruktory (332)
• Hermetyzacja (334)
• Dziedziczenie (334)
• Łańcuchowanie konstruktorów (336)
• Polimorfizm (337)
• Podsumowanie (340)

Dodatek B. Wprowadzenie do języka Groovy (341)

• Pierwsze kroki (341)
  • Powłoka GroovyShell (342)
  • Konsola GroovyConsole (343)
• Typy GString (345)
  • Jednowierszowe łańcuchy znaków (346)
  • Wielowierszowe łańcuchy znaków (347)
  • Ukośnikowe łańcuchy znaków (347)
  • Wielowierszowe ukośnikowe łańcuchy znaków (348)
  • Dolarowe ukośnikowe łańcuchy znaków (348)
• Zbiorowe typy danych (350)
  • Tablice (350)
  • Listy (350)
  • Mapy (351)
  • Przedziały (352)
  • Zbiory (353)
• Metody (354)
• Domknięcia (354)
  • Na czym polega domknięcie (355)
  • Zmienne niejawne (356)
  • Jawne deklaracje domknięcia (357)
  • Ponowne użycie metody jako domknięcia (357)
  • Przekazywanie domknięcia jako parametru (357)
• Operatory wyspecjalizowane (358)
  • Operator spread (358)
  • Operator Elvis (358)
  • Operator bezpiecznej nawigacji/dereferencji (358)
  • Operator pola (359)
  • Operator domknięcia metody (360)
  • Operator diamentowy (360)
• Podsumowanie (360)

Dodatek C. Wprowadzenie do języka Scala (361)

• Pierwsze kroki z językiem Scala (361)
  • Korzystanie z interaktywnego interpretera (361)
  • Wykonywanie kodu języka Scala jako skryptu (362)
  • Kompilacja kodu języka Scala (362)
• Zmienne (363)
• Kolekcje (364)
  • Listy (364)
  • Zestawy (365)
  • Mapy (366)
• Klasy (366)
  • Rozszerzanie klasy (366)
• Cechy (368)
• Obiekty singleton (369)
• Podsumowanie (370)