Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ JAVA

Spring Framework. Wprowadzenie do tworzenia aplikacji. Wydanie II Język: 1

978-83-283-0929-6

Cena Brutto: 68.25

Cena netto: 65.00

Ilość:
Wersja: Drukowana
Autor J Sharma, Ashish Sarin
Liczba_stron 480
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2015-09-11

Spring Framework

Wprowadzenie do tworzenia aplikacji. Wydanie II


Pojawienie się na rynku Spring Framework było jednym z istotnych punktów zwrotnych w historii języka Java. Dzięki tej bibliotece tworzenie aplikacji w Javie stało się przyjemnością, a zadania, które do tej pory spędzały programistom sen z powiek, okazały się trywialne. Spring wciąż jest rozwijany, a każda kolejna wersja wprowadza powiew świeżości do świata Javy!

Jeżeli chcesz poznać możliwości tego frameworka oraz wykorzystać drzemiący w nim potencjał w Twoim kolejnym projekcie, to trafiłeś na doskonałą książkę. Wprowadzi Cię ona bezboleśnie w świat odwróconej kontroli (Inversion of Control, w skrócie IoC), wstrzykiwania zależności oraz łatwego dostępu do danych i tworzenia aplikacji internetowych. Każda kolejna strona to bezcenna wiedza na temat tworzenia REST-owych interfejsów API, bezpieczeństwa aplikacji (Spring Security) oraz korzystania z usług JMS. Książka ta będzie świetnym wyborem, jeżeli chcesz poznać ten wyjątkowy szkielet!

Dzięki tej książce:
  • poznasz możliwości Spring Framework
  • zaznajomisz się z dostępnymi adnotacjami i skutkami ich zastosowania
  • zbudujesz aplikację internetową w architekturze MVC
  • skorzystasz z zaawansowanych mechanizmów bezpieczeństwa dzięki Spring Security
  • błyskawicznie wykorzystasz potencjał drzemiący w Spring Framework


Wprowadzenie (15)

 

Rozdział 1. Wprowadzenie do frameworku Spring (17)

 

  • 1.1. Wprowadzenie (17)
  • 1.2. Moduły frameworku Spring (17)
  • 1.3. Kontener IoC (18)
  • 1.4. Zalety stosowania frameworku Spring (21)
    • Spójne podejście w zakresie zarządzania transakcjami lokalnymi i globalnymi (21)
    • Deklaracyjne zarządzanie transakcjami (23)
    • Zapewnienie bezpieczeństwa (24)
    • JMX (Java Management Extensions) (24)
    • JMS (Java Message Service) (26)
    • Buforowanie (27)
  • 1.5. Prosta aplikacja Springa (28)
    • Identyfikacja obiektów aplikacji i ich zależności (28)
    • Utworzenie klas POJO odpowiadających zidentyfikowanym obiektom aplikacji (29)
    • Utworzenie metadanych konfiguracyjnych (30)
    • Utworzenie egzemplarza kontenera Springa (35)
    • Uzyskanie dostępu do obiektów aplikacji z poziomu egzemplarza kontenera Springa (36)
  • 1.6. Frameworki zbudowane na bazie Springa (37)
  • 1.7. Podsumowanie (38)
Rozdział 2. Podstawy frameworku Spring (39)

 

  • 2.1. Wprowadzenie (39)
  • 2.2. Reguła projektowa o nazwie "podejście oparte na programowaniu interfejsów" (39)
    • Scenariusz: klasa zależna zawiera odwołanie do konkretnej klasy zależności (39)
    • Scenariusz: klasa zależna zawiera odwołanie do interfejsu implementowanego przez zależność (40)
    • Oferowana przez Spring obsługa podejścia opartego na programowaniu interfejsu (42)
  • 2.3. Różne podejścia podczas tworzenia komponentów Springa (44)
    • Utworzenie komponentu za pomocą statycznej metody fabryki (44)
    • Tworzenie komponentu za pomocą metody fabryki egzemplarza (46)
  • 2.4. Techniki wstrzykiwania zależności (47)
    • Wstrzykiwanie zależności za pomocą metody typu setter (47)
    • Wstrzykiwanie zależności za pomocą argumentów konstruktora (51)
  • 2.5. Zasięg komponentu (54)
    • Singleton (55)
    • Prototyp (63)
    • Wybór właściwego zasięgu dla komponentu (64)
  • 2.6. Podsumowanie (64)
Rozdział 3. Konfiguracja komponentów (65)

 

  • 3.1. Wprowadzenie (65)
  • 3.2. Dziedziczenie definicji komponentu (65)
    • Przykład dziedziczenia definicji komponentu w aplikacji MyBank (65)
    • Co jest dziedziczone? (68)
  • 3.3. Dopasowanie argumentu konstruktora (73)
    • Przekazywanie wartości i odwołań do komponentów za pomocą elementu <constructor-arg> (73)
    • Dopasowanie argumentu konstruktora na podstawie typu (74)
    • Dopasowanie argumentu konstruktora na podstawie nazwy argumentu (79)
  • 3.4. Konfiguracja różnego typu właściwości komponentu i argumentów konstruktora (82)
    • Wbudowane edytory właściwości (83)
    • Określanie wartości dla różnych typów kolekcji (86)
    • Definiowanie wartości dla tablic (92)
    • Domyślne implementacje kolekcji dla elementów <list>, <set> i <map> (92)
  • 3.5. Wbudowane edytory właściwości (93)
    • Edytor CustomCollectionEditor (93)
    • Edytor CustomMapEditor (96)
    • Edytor CustomDateEditor (96)
  • 3.6. Rejestracja edytorów właściwości w kontenerze Springa (97)
    • Utworzenie implementacji PropertyEditorRegistrar (97)
    • Konfiguracja klasy CustomEditorConfigurer (98)
  • 3.7. Zwięzłe definicje komponentów dzięki użyciu przestrzeni nazw p oraz c (99)
    • Przestrzeń nazw p (99)
    • Przestrzeń nazw c (100)
  • 3.8. Schemat util (103)
    • Element <list> (104)
    • Element <map> (105)
    • Element <set> (107)
    • Element <properties> (109)
    • Element <constant> (110)
    • Element <property-path> (111)
  • 3.9. Interfejs FactoryBean (113)
    • Aplikacja MyBank - przechowywanie zdarzeń w bazie danych (113)
    • Aplikacja MyBank - przykład użycia interfejsu FactoryBean (115)
    • Uzyskanie dostępu do egzemplarza FactoryBean (118)
  • 3.10. Podsumowanie (120)
Rozdział 4. Wstrzykiwanie zależności (121)

 

  • 4.1. Wprowadzenie (121)
  • 4.2. Komponenty wewnętrzne (121)
  • 4.3. Wyraźna kontrola kolejności inicjalizacji procesu za pomocą atrybutu depends-on (123)
    • Aplikacja MyBank - zasugerowane zależności między komponentami (123)
    • Problem niejawnej zależności (124)
  • 4.4. Zależności w postaci komponentów o zasięgu singleton i prototypu (129)
    • Zależności komponentu o zasięgu singleton (129)
    • Zależności komponentu o zasięgu prototypu (132)
  • 4.5. Pobieranie w komponencie singleton nowego egzemplarza komponentu o zasięgu prototypu (135)
    • Interfejs ApplicationContextAware (136)
    • Element <lookup-method> (138)
    • Element <replaced-method> (142)
  • 4.6. Automatyczne wiązanie zależności (145)
    • Wartość byType (146)
    • Wartość constructor (147)
    • Wartość byName (148)
    • Wartości default i no (150)
    • Uniedostępnienie komponentu dla funkcji automatycznego wiązania (150)
    • Ograniczenia automatycznego wiązania (152)
  • 4.7. Podsumowanie (153)
Rozdział 5. Dostosowanie komponentów i ich definicji (155)

 

  • 5.1. Wprowadzenie (155)
  • 5.2. Dostosowanie logiki inicjalizacji i usuwania komponentu (155)
    • Wywołanie przez Spring metody czyszczącej wskazanej przez atrybut destroy-method (158)
    • Metoda czyszcząca i komponent o zasięgu prototypu (160)
    • Określenie domyślnych metod inicjalizacji i usuwania obiektu dla wszystkich komponentów (160)
    • Interfejsy cyklu życiowego InitializingBean i DisposableBean (161)
    • Adnotacje @PostConstruct i @PreDestroy wprowadzone w specyfikacji JSR 250 (161)
  • 5.3. Użycie interfejsu BeanPostProcessor do pracy z nowo utworzonym egzemplarzem komponentu (163)
    • Przykład użycia interfejsu BeanPostProcessor - weryfikacja egzemplarzy komponentu (165)
    • Przykład BeanPostProcessor - rozwiązywanie zależności komponentu (168)
    • Zachowanie BeanPostProcessor w przypadku komponentów implementujących FactoryBeans (172)
    • RequiredAnnotationBeanPostProcessor (174)
    • DestructionAwareBeanPostProcessor (175)
  • 5.4. Modyfikacja definicji komponentu za pomocą BeanFactoryPostProcessor (176)
    • Przykład użycia BeanFactoryPostProcessor (177)
    • Komponent PropertySourcesPlaceholderConfigurer (182)
    • Komponent PropertyOverrideConfigurer (187)
  • 5.5. Podsumowanie (190)
Rozdział 6. Programowanie oparte na adnotacjach (191)

 

  • 6.1. Wprowadzenie (191)
  • 6.2. Identyfikacja komponentów Springa za pomocą adnotacji @Component (191)
  • 6.3. Adnotacja @Autowired, czyli automatyczne wiązanie zależności według ich typu (194)
  • 6.4. Adnotacja @Qualifier pozwalająca na automatyczne wiązanie zależności według ich nazwy (198)
  • 6.5. Adnotacje @Inject i @Named zdefiniowane przez specyfikację JSR 330 (199)
  • 6.6. Zdefiniowana przez JSR 250 adnotacja @Resource (201)
  • 6.7. Adnotacje @Scope, @Lazy, @DependsOn i @Primary (202)
  • 6.8. Ułatwienie konfiguracji komponentu za pomocą adnotacji @Value (203)
  • 6.9. Weryfikacja obiektów za pomocą interfejsu Validator (207)
  • 6.10. Określanie ograniczeń za pomocą adnotacji JSR 303 (211)
    • Obsługa specyfikacji JSR 303 w Springu (212)
  • 6.11. Programowa konfiguracja komponentów Springa za pomocą adnotacji @Configuration i @Bean (216)
  • 6.12. Podsumowanie (219)
Rozdział 7. Współpraca z bazą danych (221)

 

  • 7.1. Wprowadzenie (221)
  • 7.2. Wymagania aplikacji MyBank (221)
  • 7.3. Utworzenie aplikacji MyBank opartej na module JDBC (222)
    • Konfiguracja źródła danych (223)
    • Tworzenie obiektów DAO używających klas modułu JDBC (224)
  • 7.4. Utworzenie aplikacji MyBank z użyciem Hibernate (231)
    • Konfiguracja SessionFactory (231)
    • Utworzenie klas DAO używających do pracy z bazą danych API Hibernate (232)
  • 7.5. Zarządzanie transakcjami za pomocą Springa (233)
    • Wymagania aplikacji MyBank w zakresie zarządzania transakcjami (233)
    • Programowe zarządzanie transakcjami (234)
    • Deklaracyjne zarządzanie transakcjami (238)
    • Oferowana przez Spring obsługa JTA (241)
  • 7.6. Podsumowanie (243)
Rozdział 8. Komunikaty, wiadomości e-mail, asynchroniczne wykonywanie metod i buforowanie w Springu (245)

 

  • 8.1. Wprowadzenie (245)
  • 8.2. Wymagania aplikacji MyBank (245)
  • 8.3. Wysyłanie komunikatów JMS (246)
    • Konfiguracja brokera ActiveMQ do działania w trybie osadzonym (247)
    • Konfiguracja JMS ConnectionFactory (247)
    • Wysyłanie komunikatów JMS za pomocą klasy JmsTemplate (248)
    • Wysyłanie komunikatów JMS w transakcji (249)
    • Dynamiczni odbiorcy komunikatów JMS i konfiguracja klasy JmsTemplate (253)
    • Klasa JmsTemplate i konwersja komunikatu (254)
  • 8.4. Odbieranie komunikatów JMS (255)
    • Synchroniczne odbieranie komunikatów JMS za pomocą klasy JmsTemplate (255)
    • Asynchroniczne odbieranie komunikatów JMS za pomocą kontenerów odbiorców komunikatów (255)
  • 8.5. Wysyłanie wiadomości e-mail (258)
  • 8.6. Harmonogram zadań i wykonywanie asynchroniczne (263)
    • Interfejs TaskExecutor (263)
    • Interfejs TaskScheduler (265)
    • Adnotacje @Async i @Scheduled (267)
  • 8.7. Buforowanie (269)
    • Konfiguracja interfejsu CacheManager (271)
    • Adnotacje buforowania @Cacheable, @CacheEvict i @CachePut (271)
  • 8.8. Aplikacja MyBank (275)
  • 8.9. Podsumowanie (277)
Rozdział 9. Programowanie zorientowane aspektowo (279)

 

  • 9.1. Wprowadzenie (279)
  • 9.2. Prosty przykład AOP (279)
  • 9.3. Oferowany przez Spring framework AOP (282)
    • Tworzenie proxy (283)
    • Atrybut expose-proxy (284)
  • 9.4. Wyrażenia punktu przecięcia (286)
    • Adnotacja @Pointcut (286)
    • Desygnatory execution i args (287)
    • Desygnator bean (291)
    • Desygnatory oparte na adnotacjach (292)
  • 9.5. Typy rad (293)
    • Rada before (293)
    • Rada after returning (294)
    • Rada after throwing (295)
    • Rada after (296)
    • Rada around (297)
  • 9.6. Spring AOP, czyli styl schematu XML (298)
    • Konfiguracja aspektu AOP (299)
    • Konfiguracja rady (300)
    • Powiązanie wyrażenia punktu przecięcia z radą (301)
  • 9.7. Podsumowanie (302)
Rozdział 10. Podstawy modułu Spring Web MVC (303)

 

  • 10.1. Wprowadzenie (303)
  • 10.2. Struktura katalogów przykładowych projektów (303)
  • 10.3. Poznajemy przykładową aplikację (304)
    • Plik HelloWorldController.java, czyli klasa kontrolera aplikacji sieciowej Hello World (305)
    • Plik helloworld.js, czyli strona JSP wyświetlająca komunikat (306)
    • Plik myapp-config.xml, czyli plik XML kontekstu aplikacji sieciowej (307)
    • Plik web.xml, czyli deskryptor wdrożenia aplikacji sieciowej (308)
  • 10.4. Serwlet DispatcherServlet (311)
    • Uzyskanie dostępu do obiektów ServletContext i ServletConfig (313)
  • 10.5. Opracowanie kontrolerów za pomocą adnotacji @Controller i @RequestMapping (314)
    • Opracowanie aplikacji sieciowej za pomocą kontrolera oznaczonego adnotacją (314)
  • 10.6. Wymagania aplikacji sieciowej MyBank (317)
  • 10.7. Adnotacje Spring Web MVC: @RequestMapping i @RequestParam (318)
    • Mapowanie żądań na kontrolery lub metody kontrolerów za pomocą adnotacji @RequestMapping (318)
    • Argumenty metod oznaczonych adnotacją @RequestMapping (324)
    • Typy wartości zwrotnych metod oznaczonych adnotacją @RequestMapping (325)
    • Przekazanie parametrów żądania do metod kontrolera z użyciem adnotacji @RequestParam (326)
  • 10.8. Weryfikacja (330)
  • 10.9. Obsługa wyjątków za pomocą adnotacji @ExceptionHandler (333)
  • 10.10. Wczytanie głównego pliku XML kontekstu aplikacji sieciowej (335)
  • 10.11. Podsumowanie (335)
Rozdział 11. Weryfikacja i dołączanie danych w Spring Web MVC (337)

 

  • 11.1. Wprowadzenie (337)
  • 11.2. Dodawanie i pobieranie atrybutów modelu za pomocą adnotacji @ModelAttribute (337)
    • Dodanie atrybutów modelu za pomocą adnotacji @ModelAttribute stosowane na poziomie metody (338)
    • Pobieranie atrybutów modelu za pomocą adnotacji @ModelAttribute (342)
    • Przetwarzanie żądania i metody oznaczone adnotacją @ModelAttribute (343)
    • Zachowanie argumentów metody oznaczonych adnotacją @ModelAttribute (345)
    • Obiekt RequestToViewNameTranslator (346)
  • 11.3. Buforowanie atrybutów modelu za pomocą adnotacji @SessionAttributes (347)
  • 11.4. Dołączanie danych (350)
    • WebDataBinder, czyli dołączanie danych dla parametrów żądania sieciowego (352)
    • Konfiguracja egzemplarza WebDataBinder (353)
    • Włączenie lub wyłączenie poszczególnych właściwości w procesie dołączania danych (358)
    • Analiza błędów dołączania danych i weryfikacji przechowywanych przez obiekt BindingResult (361)
  • 11.5. Weryfikacja w Springu (362)
    • Weryfikacja atrybutów modelu za pomocą oferowanego przez Spring interfejsu Validator (363)
    • Zdefiniowanie ograniczeń za pomocą adnotacji JSR 303 (366)
    • Weryfikacja obiektu używającego adnotacji JSR 303 (367)
  • 11.6. Biblioteka znaczników form (371)
    • Obsługa HTML5 przez bibliotekę form (372)
  • 11.7. Podsumowanie (374)
Rozdział 12. Tworzenie usług sieciowych typu RESTful za pomocą Spring Web MVC (375)

 

  • 12.1. Wprowadzenie (375)
  • 12.2. Usługa sieciowa do obsługi lokat (376)
  • 12.3. Implementacja usługi sieciowej w stylu RESTful za pomocą Spring Web MVC (376)
    • Format JSON (377)
    • Implementacja usługi sieciowej FixedDepositWS (379)
  • 12.4. Uzyskanie dostępu do usługi sieciowej w stylu RESTful za pomocą klasy RestTemplate (386)
  • 12.5. Użycie HttpMessageConverter do konwersji obiektów Javy na żądania lub odpowiedzi HTTP i na odwrót (394)
  • 12.6. Adnotacje @PathVariable i @MatrixVariable (395)
  • 12.7. Podsumowanie (399)
Rozdział 13. Więcej o Spring Web MVC: internacjonalizacja, przesyłanie plików i przetwarzanie żądań asynchronicznych (401)

 

  • 13.1. Wprowadzenie (401)
  • 13.2. Przetwarzanie żądań za pomocą procedur obsługi interceptorów (401)
    • Implementacja i konfiguracja procedury obsługi interceptorów (401)
  • 13.3. Internacjonalizacja za pomocą paczek zasobów (404)
    • Wymagania aplikacji sieciowej MyBank (404)
    • Internacjonalizacja i lokalizacja aplikacji sieciowej MyBank (404)
  • 13.4. Asynchroniczne przetwarzanie żądań (407)
    • Konfiguracja asynchronicznego przetwarzania żądań (407)
    • Zwrot obiektu Callable przez metodę oznaczoną adnotacją @RequestMapping (408)
    • Zwrot obiektu DeferredResult przez metodę oznaczoną adnotacją @RequestMapping (409)
    • Ustawienie domyślnego limitu czasu (416)
    • Przechwytywanie żądań asynchronicznych (417)
  • 13.5. Obsługa konwersji typu i formatowania (417)
    • Utworzenie własnej implementacji interfejsu Converter (418)
    • Konfiguracja i użycie własnej implementacji interfejsu Converter (418)
    • Tworzenie własnej implementacji Formatter (420)
    • Konfiguracja własnej implementacji Formatter (422)
    • Utworzenie implementacji AnnotationFormatterFactory do formatowania jedynie właściwości oznaczonych adnotacją @AmountFormat (422)
    • Konfiguracja implementacji AnnotationFormatterFactory (423)
  • 13.6. Obsługa przekazywania plików w Spring Web MVC (425)
    • Przekazywanie plików za pomocą implementacji CommonsMultipartResolver (425)
    • Przekazywanie plików za pomocą StandardServletMultipartResolver (427)
  • 13.7. Podsumowanie (428)
Rozdział 14. Zabezpieczanie aplikacji za pomocą Spring Security (429)

 

  • 14.1. Wprowadzenie (429)
  • 14.2. Wymagania aplikacji sieciowej MyBank w zakresie bezpieczeństwa (429)
  • 14.3. Zabezpieczanie aplikacji MyBank za pomocą frameworku Spring Security (431)
    • Konfiguracja zabezpieczeń dla żądań sieciowych (431)
    • Konfiguracja uwierzytelniania (434)
    • Zabezpieczenie zawartości strony JSP przez użycie oferowanej przez Spring Security biblioteki znaczników (435)
    • Zabezpieczanie metod (436)
  • 14.4. Zabezpieczanie egzemplarzy FixedDepositDetails za pomocą modułu ACL (440)
    • Wdrożenie i użycie projektu ch14-bankapp-db-security (440)
    • Tabele bazy danych przeznaczone do przechowywania informacji o listach ACL i użytkownikach (442)
    • Uwierzytelnianie użytkownika (446)
    • Zabezpieczenie żądań sieciowych (447)
    • Konfiguracja JdbcMutableAclService (449)
    • Konfiguracja zabezpieczeń na poziomie metody (452)
    • Bezpieczeństwo egzemplarza obiektu domeny (453)
    • Programowe zarządzanie informacjami ACL (455)
    • Egzemplarz MutableAcl i bezpieczeństwo (458)
  • 14.5. Podsumowanie (459)
Dodatek A. Import i wdrożenie przykładowych projektów w Eclipse IDE (lub IntelliJ IDEA) (461)

 

  • A.1. Przygotowanie środowiska pracy (461)
  • A.2. Import przykładowego projektu do Eclipse IDE (lub IntelliJ IDEA) (461)
    • Import przykładowego projektu (462)
    • Konfiguracja zmiennej M2_REPO w Eclipse IDE (463)
  • A.3. Konfiguracja Eclipse IDE do pracy z serwerem Tomcat 7 (463)
  • A.4. Wdrożenie projektu sieciowego w serwerze Tomcat 7 (465)
    • Uruchomienie serwera Tomcat 7 w trybie osadzonym (465)
Skorowidz (467)
powrót
 
Produkty Podobne
Java. Podstawy. Wydanie XI
Programowanie w języku Kotlin. The Big Nerd Ranch Guide
Ciągłe dostarczanie oprogramowania w języku Java. Najlepsze narzędzia i praktyki wdrażania kodu
Java dla zupełnie początkujących. Owoce programowania. Wydanie VII
Algorytmy, struktury danych i techniki programowania dla programistów Java
Java EE 8. Wzorce projektowe i najlepsze praktyki
Struktury danych i algorytmy w języku Java. Przewodnik dla początkujących
Modularny JavaScript dla zaawansowanych
Core Java, Volume II--Advanced Features, 11th Edition
Java. Kompendium programisty. Wydanie X
Więcej produktów