Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00493 008535 10488554 na godz. na dobę w sumie
Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse - książka
Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse - książka
Autor: Liczba stron: 352
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-0682-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Tworzenie zaawansowanych projektów korporacyjnych w Javie

Chciałbyś tworzyć rozbudowane aplikacje w języku Java szybciej i w prostszy sposób? Liczne narzędzia i technologie budowania programów w Javie często ułatwiają wykonywanie niektórych zadań, ale jednocześnie niepotrzebnie komplikują i wydłużają proces powstawania gotowych produktów. Jak dobrać odpowiednie techniki i zastosować metodologię, która usprawni i przyspieszy pracę? Niektórzy już to wiedzą -- Ty też możesz skorzystać z ich doświadczeń!

'Java. Tworzenie aplikacji sieciowych za pomocą Spring, Hibernate i Eclipse' to praktyczny poradnik opisujący wydajną i sprawdzoną metodologię szybkiego pisania oprogramowania w języku Java. Dzięki tej książce poznasz techniki programowania ekstremalnego oraz metodologii Agile i nauczysz się stosować je podczas pracy nad programami. Dowiesz się, jak zaprojektować aplikację, przygotować środowisko i korzystać z wiersza poleceń oraz proponowanego zestawu narzędzi -- platformy Spring, mechanizmu odwzorowań Hibernate i IDE Eclipse -- co pozwoli Ci w prosty sposób użyć zaawansowanych rozwiązań.

Zwiększ swą wydajność dzięki zastosowaniu efektywnych procesów i narzędzi do tworzenia oprogramowania w języku Java.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Java. Tworzenie aplikacji sieciowych za pomoc¹ Springa, Hibernate i Eclipse Autor: Anil Hemrajani T³umaczenie: Konrad Rymczak, Grzegorz Skorczyñski, Ewa Bucka ISBN: 978-83-246-0682-5 Tytu³ orygina³u: Agile Java Development with Spring, Hibernate and Eclipse Format: B5, stron: 352 Tworzenie zaawansowanych projektów korporacyjnych w Javie (cid:129) Poznaj sprawdzone metodologie i procesy (cid:129) Naucz siê stosowaæ praktyczne technologie i narzêdzia (cid:129) Twórz w Javie kompletne rozwi¹zania w optymalny sposób Chcia³byœ tworzyæ rozbudowane aplikacje w jêzyku Java szybciej i w prostszy sposób? Liczne narzêdzia i technologie budowania programów w Javie czêsto u³atwiaj¹ wykonywanie niektórych zadañ, ale jednoczeœnie niepotrzebnie komplikuj¹ i wyd³u¿aj¹ proces powstawania gotowych produktów. Jak dobraæ odpowiednie techniki i zastosowaæ metodologiê, która usprawni i przyspieszy pracê? Niektórzy ju¿ to wiedz¹ — Ty te¿ mo¿esz skorzystaæ z ich doœwiadczeñ! „Java. Tworzenie aplikacji sieciowych za pomoc¹ Spring, Hibernate i Eclipse” to praktyczny poradnik opisuj¹cy wydajn¹ i sprawdzon¹ metodologiê szybkiego pisania oprogramowania w jêzyku Java. Dziêki tej ksi¹¿ce poznasz techniki programowania ekstremalnego oraz metodologii Agile i nauczysz siê stosowaæ je podczas pracy nad programami. Dowiesz siê, jak zaprojektowaæ aplikacjê, przygotowaæ œrodowisko i korzystaæ z wiersza poleceñ oraz proponowanego zestawu narzêdzi — platformy Spring, mechanizmu odwzorowañ Hibernate i IDE Eclipse — co pozwoli Ci w prosty sposób u¿yæ zaawansowanych rozwi¹zañ. (cid:129) Techniki programowania ekstremalnego (XP) (cid:129) Wprowadzenie do metodologii Agile (cid:129) Korzystanie z platformy Spring (cid:129) Utrwalanie obiektów za pomoc¹ Hibernate (cid:129) Praca w IDE Eclipse (cid:129) Debugowanie oprogramowania (cid:129) Monitorowanie i profilowanie aplikacji (cid:129) Refaktoryzacja kodu Zwiêksz sw¹ wydajnoœæ dziêki zastosowaniu efektywnych procesów i narzêdzi do tworzenia oprogramowania w jêzyku Java. Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści 5 Przedmowa .................................................................................... 13 O autorze ....................................................................................... 17 Podziękowania ............................................................................... 19 Wstęp ............................................................................................ 23 Część I Wprowadzenie .............................................................. 31 Rozdział 1. Wstęp ............................................................................................ 33 Co jest omawiane w tym rozdziale? ................................................................................ 34 Technologie użyte w tej książce ...................................................................................... 34 Technologie uruchomieniowe ................................................................................... 36 Narzędzia programistyczne ....................................................................................... 38 Metodologie wytwarzania oprogramowania użyte w tej książce .................................... 42 Podsumowanie ................................................................................................................. 43 Rekomendowane źródła .................................................................................................. 43 Rozdział 2. Przykładowa aplikacja: Time Expression .......................................... 45 Co jest omawiane w tym rozdziale? ................................................................................ 46 Wymagania biznesowe .................................................................................................... 47 Metodologie wytwarzania oprogramowania ................................................................... 48 Informacje wstępne o XP i AMDD ........................................................................... 48 Etap badań ................................................................................................................. 50 Etap planowania ........................................................................................................ 51 Etap wydania a iteracje (etapowe wytwarzanie oprogramowania) ........................... 52 Zakres projektu .......................................................................................................... 52 Utrzymanie ................................................................................................................ 53 Stosujemy XP i AMDD w naszej przykładowej aplikacji .............................................. 53 Model domenowy ...................................................................................................... 53 Prototyp interfejsu użytkownika (UI) ....................................................................... 53 Scenopis .................................................................................................................... 57 Historie użytkownika ................................................................................................ 57 Plan wydań (i iteracji) ............................................................................................... 60 Słownik ...................................................................................................................... 61 Architektura tablicowa .............................................................................................. 62 6 Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse Uwaga na temat oprogramowania Wiki .......................................................................... 63 Podsumowanie ................................................................................................................. 63 Rekomendowane źródła .................................................................................................. 64 Część II Tworzymy przykładową aplikację ................................... 65 Rozdział 3. Metodologie XP i AMDD ................................................................. 67 Co jest omawiane w tym rozdziale? ................................................................................ 68 Projektowanie i wybór artefaktów ................................................................................... 69 Diagram architektury ....................................................................................................... 70 Od historii użytkownika do projektu ............................................................................... 71 Analizujemy klasy przy pomocy kart CRC ..................................................................... 71 Mapa przepływu aplikacji (artefakt domowej roboty) .................................................... 73 Technika uzupełniająca ............................................................................................. 74 Rozszerzamy mapę przepływu aplikacji o kolumny CRUD ..................................... 74 UML — diagram klas ...................................................................................................... 74 Diagramy pakietów UML ................................................................................................ 76 Struktura katalogów ......................................................................................................... 77 Przykładowe nazwy plików ............................................................................................. 77 Wytwarzanie oprogramowania od początku do końca .................................................... 78 Testy akceptacyjne .......................................................................................................... 78 Logowanie ................................................................................................................. 79 Lista kart pracy .......................................................................................................... 79 Wprowadź godziny ................................................................................................... 79 Inne rozważania ............................................................................................................... 79 Podsumowanie ................................................................................................................. 80 Rekomendowane źródła .................................................................................................. 82 Rozdział 4. Konfiguracja środowiska: JDK, Ant i JUnit ....................................... 83 Co jest omawiane w tym rozdziale? ................................................................................ 84 Java Platform Standard Edition Development Kit (JDK) ............................................... 84 Struktura katalogów ......................................................................................................... 85 Ant ................................................................................................................................... 86 Prosty plik budujący .................................................................................................. 86 Złożony plik budujący ............................................................................................... 87 JUnit ................................................................................................................................. 90 Samodzielnie uruchomiony JUnit ............................................................................. 91 JUnit z poziomu Eclipse ............................................................................................ 92 SimpleTest: sprawiamy, że wszystkie narzędzia współpracują razem ............................ 92 SimpleTest.java ......................................................................................................... 93 Rodzaje metod assert w JUnit ................................................................................... 93 Uruchamiamy SimpleTest (pojedynczy test JUnit) .................................................. 94 Uruchamiamy testy JUnit jako zadanie Anta ............................................................ 95 Wstępne testy i refaktoryzacja ......................................................................................... 96 Podsumowanie ................................................................................................................. 97 Rekomendowane źródła .................................................................................................. 98 Rozdział 5. Hibernate — zapewniamy trwałość obiektów ................................... 99 Co jest omawiane w tym rozdziale? .............................................................................. 100 Zarys odwzorowania obiektowo-relacyjnego (Object-Relational Mapping — ORM) ....................................................................... 101 Relacje i liczebność ................................................................................................. 102 Tożsamość obiektu .................................................................................................. 103 Kaskada ................................................................................................................... 103 Spis treści 7 Odwzorowanie ........................................................................................................ 103 Obiekty w pamięci kontra obiekty trwałe ............................................................... 104 Projekt naszej przykładowej bazy danych ..................................................................... 104 Denormalizacja ........................................................................................................ 104 Konwencje nazewnicze ........................................................................................... 105 Uwagi do projektowania bazy danych .................................................................... 106 Skrypt DDL ............................................................................................................. 106 Gdzie w naszej aplikacji znajduje się HSQLDB i Hibernate? ...................................... 107 HSQLDB ....................................................................................................................... 108 Serwer HSQLDB i przydatne zadania Anta ............................................................ 108 HSQLDB Database Manager i SqlTool .................................................................. 109 Tryby persistent i in-memory w HSQLDB ............................................................. 109 Dołączamy HSQLDB do archiwum naszej aplikacji .............................................. 110 Pracujemy z Hibernate ................................................................................................... 110 Nie potrzeba DAO ani DTO .................................................................................... 111 Obsługiwane bazy danych ....................................................................................... 111 Hibernate i EJB 3.x ................................................................................................. 111 Przykładowy test konfiguracji Hibernate ................................................................ 112 Instalacja Hibernate ................................................................................................. 115 Podstawy pracy z Hibernate .................................................................................... 117 Tworzymy TimesheetManager.java, korzystając z Hibernate ................................ 120 Employee.* i DepartmentManager.java .................................................................. 124 Pliki wymagane w ścieżce klas ............................................................................... 124 Uruchamiamy zestaw testów przy pomocy Anta .................................................... 124 Usuwamy rekordy ................................................................................................... 125 Interfejs Criteria ...................................................................................................... 125 Obsługa wyjątków ................................................................................................... 126 Pozostałe funkcje Hibernate .......................................................................................... 127 Asocjacje ................................................................................................................. 127 Blokowanie obiektów (kontrola współbieżności) ................................................... 127 Jeszcze więcej Hibernate ......................................................................................... 129 Podsumowanie ............................................................................................................... 129 Rekomendowane źródła ................................................................................................ 130 Rozdział 6. Wprowadzenie do Spring Framework ............................................. 133 Co jest omawiane w tym rozdziale? .............................................................................. 135 Czym jest Spring? .......................................................................................................... 135 Pakiety Springa służące do rozwijania aplikacji ........................................................... 136 Pakiety Springa służące do wdrażania aplikacji ............................................................ 137 Przegląd modułów Springa ............................................................................................ 138 Spring Core ............................................................................................................. 138 Spring Context ......................................................................................................... 138 Spring AOP ............................................................................................................. 138 Spring DAO ............................................................................................................. 138 Spring ORM ............................................................................................................ 140 Gdzie w naszej architekturze jest miejsce Spring Framework? .................................... 140 Korzyści płynące z użycia Springa ................................................................................ 141 Główne koncepcje Springa ............................................................................................ 142 Wzorzec wstrzykiwania zależności (i kontenery IoC) ............................................ 143 Dwa style wstrzykiwana .......................................................................................... 143 Bean, BeanFactory i ApplicationContext ................................................................ 144 Edytory właściwości ............................................................................................... 146 Podprojekty Springa ...................................................................................................... 146 Podsumowanie ............................................................................................................... 147 Rekomendowane źródła ................................................................................................ 147 8 Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse Rozdział 7. Framework Spring Web MVC ........................................................ 149 Co jest omawiane w tym rozdziale? .............................................................................. 150 Zalety Spring MVC ....................................................................................................... 150 Pojęcia związane ze Spring Web MVC ......................................................................... 152 Spring MVC a Java ................................................................................................. 152 Konfiguracja Spring MVC ...................................................................................... 155 Konfiguracja Springa dla Time Expression ................................................................... 156 Instalowanie kontenera serwletów (Apache Tomcat) ............................................. 157 Instalowanie Spring Framework ............................................................................. 158 Uruchomienie SpringTest ....................................................................................... 159 Konfiguracja Spring MVC ...................................................................................... 159 Budowanie interfejsu użytkownika z pomocą Springa ................................................. 160 Ekran: Lista kart pracy ............................................................................................ 160 Ekran: Wprowadź godziny ...................................................................................... 161 Kaskadowe arkusze stylów (Cascading Style Sheets — CSS) ...................................... 162 Ekran: Lista kart pracy — przykład kontrolera bez formularza .................................... 163 Konfiguracja krok po kroku .................................................................................... 163 Kodowanie krok po kroku ....................................................................................... 164 Ekran: Wprowadź godziny — przykład kontrolera formularza .................................... 168 Konfiguracja krok po kroku .................................................................................... 168 Kodowanie krok po kroku ....................................................................................... 170 Wiązanie do niestandardowych (niebiznesowych) obiektów polecenia ................. 174 DateUtil.java ........................................................................................................... 175 Dyrektywy taglib w JSP .......................................................................................... 175 Widok bez kontrolera .................................................................................................... 175 Obiekty przechwytujące w Springu ............................................................................... 175 Uwierzytelnianie w Time Expression ..................................................................... 176 Nasza przykładowa aplikacja — pierwsze uruchomienie ............................................. 177 Nowe biblioteki znaczników w Spring Framework 2.0 ................................................ 177 Słowo o Spring Web Flow i Portlet API ....................................................................... 180 Spring Web Flow .................................................................................................... 180 Spring Portlet API ................................................................................................... 180 Podsumowanie ............................................................................................................... 181 Rekomendowane źródła ................................................................................................ 181 Rozdział 8. Fenomen środowiska Eclipse ........................................................ 183 Co jest omawiane w tym rozdziale? .............................................................................. 184 Fundacja Eclipse ............................................................................................................ 185 Eclipse — platforma i projekty ..................................................................................... 186 Koncepcje związane z Eclipse SDK .............................................................................. 188 Workspace — przestrzeń projektów ....................................................................... 189 Workbench — obszar roboczy, perspektywy, edytory i widoki ............................. 189 Projekt ..................................................................................................................... 191 Pluginy .................................................................................................................... 192 Kreatory ................................................................................................................... 192 Instalacja Eclipse ........................................................................................................... 192 Konfiguracja Eclipse na potrzeby Time Expression ..................................................... 195 Java Development Tools (JDT) — narzędzia programistyczne dla Javy ...................... 200 Instalacja pluginów WTP — zestawu narzędzi do rozwoju aplikacji sieciowych ........ 208 Praca z Eclipse — rozwijamy Time Expression ........................................................... 209 Wbudowane pluginy JDT ........................................................................................ 210 Plugin z kategorii Data (dla HSQLDB) .................................................................. 212 Pluginy do obsługi serwerów (dla Tomcata) ........................................................... 212 Plugin Hibernate ...................................................................................................... 214 Spis treści 9 Plugin Spring IDE ................................................................................................... 215 Inne godne uwagi pluginy WTP .............................................................................. 217 Więcej Eclipse? Tak, jest pełno pluginów ..................................................................... 217 Projekty Eclipse.org ................................................................................................ 217 Katalogi pluginów ................................................................................................... 218 MyEclipseIDE.com ................................................................................................. 218 Google.com ............................................................................................................. 219 Wsparcie dla pracy zespołowej w Eclipse ..................................................................... 219 System pomocy w Eclipse ............................................................................................. 220 Wskazówki i porady ...................................................................................................... 220 Skróty klawiaturowe ............................................................................................... 221 Preferencje ............................................................................................................... 224 Zakładki ................................................................................................................... 225 Uruchamianie zewnętrznych narzędzi i przeglądarki WWW ................................. 225 Historia lokalna ....................................................................................................... 226 Resetowanie perspektywy ....................................................................................... 226 Kopiowanie elementów ........................................................................................... 226 Czyszczenie projektów ............................................................................................ 226 Konwersja znaków końca linii ................................................................................ 227 Parametry startowe Eclipse/JVM ............................................................................ 227 Przeglądanie obcego kodu ....................................................................................... 227 Ukryte pliki Eclipse ................................................................................................. 227 Deinstalowanie Eclipse .................................................................................................. 227 Subiektywne porównanie do IntelliJ i NetBeans ........................................................... 228 IntelliJ 5.0 ................................................................................................................ 228 NetBeans 5.0 ........................................................................................................... 229 Porównanie czasów uruchomienia .......................................................................... 230 Podsumowanie ............................................................................................................... 231 Rekomendowane źródła ................................................................................................ 232 Część III Zaawansowane cechy ................................................ 233 Rozdział 9. Zapis logów, debugowanie, monitorowanie i profilowanie ................. 235 Co jest omawiane w tym rozdziale? .............................................................................. 236 Opis koncepcji zapisu logów ......................................................................................... 237 Zapis logów przy użyciu biblioteki Jakarta Commons Logging (z wykorzystaniem Log4j oraz JDK) .......................................................................................................... 238 Jak działa JCL? ........................................................................................................ 239 Programowanie z użyciem JCL ............................................................................... 239 Priorytety komunikatów .......................................................................................... 240 Przykład zapisu logów w TimesheetListController ................................................ 241 Uwaga na temat klas formatujących ....................................................................... 242 Wykorzystanie logowania w Spring i Hibernate ..................................................... 242 Debugowanie aplikacji w Javie z wykorzystaniem środowiska Eclipse ....................... 242 Koncepcje i cechy debugera JDT ............................................................................ 243 Debugowanie aplikacji internetowych z użyciem Firefoksa ......................................... 247 Debuger JavaScript ................................................................................................. 247 Web Developer ........................................................................................................ 248 Inne rozszerzenia Firefoksa ..................................................................................... 248 Konsola JavaScript .................................................................................................. 249 Całościowe debugowanie klasy TimesheetManagerTest (od przeglądarki do bazy danych) ........................................................................................................................ 249 Zarządzanie i monitorowanie z wykorzystaniem technologii JMX .............................. 251 Programy profilujące w Javie ........................................................................................ 252 10 Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse Porady przy debugowaniu ............................................................................................. 252 Podsumowanie ............................................................................................................... 253 Rekomendowane źródła ................................................................................................ 254 Rozdział 10. Elementy zaawansowane .............................................................. 257 Co jest omawiane w tym rozdziale? .............................................................................. 258 Nowości w Javie 1.5 ...................................................................................................... 258 Importy statyczne .................................................................................................... 259 Typy sparametryzowane — generics ...................................................................... 259 Ulepszone pętle ....................................................................................................... 259 Automatyczne opakowywanie — autoboxing ........................................................ 260 Typ wyliczeniowy — enum .................................................................................... 260 Zmienna liczba argumentów ................................................................................... 260 Inne nowości ........................................................................................................... 261 Zadania narzędzia Ant ................................................................................................... 261 CVS ......................................................................................................................... 262 Exec ......................................................................................................................... 262 Get ........................................................................................................................... 262 Sleep ........................................................................................................................ 262 Ftp ............................................................................................................................ 263 Mail ......................................................................................................................... 263 Obfitość zadań! ....................................................................................................... 263 JUnit ............................................................................................................................... 264 Niestandardowe zestawy testowe ............................................................................ 264 Powtarzający się kod ............................................................................................... 264 Hibernate ....................................................................................................................... 265 Natywne zapytania SQL .......................................................................................... 265 Obiekty przechwytujące .......................................................................................... 266 Spring Framework ......................................................................................................... 266 Zadania zaplanowane .............................................................................................. 267 Spring — wsparcie dla poczty elektronicznej ......................................................... 268 Wsparcie dla JMX ................................................................................................... 269 Więcej Springa ........................................................................................................ 271 Integracja Spring i Hibernate ......................................................................................... 272 Konfiguracja zarządzania transakcjami w Spring ................................................... 272 Mniejszy i czystszy kod .......................................................................................... 274 Testy jednostkowe naszego zintegrowanego kodu ................................................. 276 Podejście bazujące na interfejsie ............................................................................. 276 Biblioteka znaczników JSP ........................................................................................... 277 Displaytag ................................................................................................................ 277 Własna biblioteka znaczników ................................................................................ 278 Refaktoryzacja ............................................................................................................... 279 Przykłady refaktoryzacji w naszej aplikacji ............................................................ 279 Refaktoryzuj bezlitośnie, ale… zachowaj kopię kodu ............................................ 280 Zasoby internetowe związane z refaktoryzacją (refactoring.com i agiledata.org) ...... 281 Uwaga na temat refaktoryzacji w Eclipse ............................................................... 281 Inne rozważania ............................................................................................................. 281 Zarządzanie transakcjami ........................................................................................ 281 Bezpieczeństwo aplikacji ........................................................................................ 283 Obsługa wyjątków ................................................................................................... 285 Łączenie w klastry ......................................................................................................... 287 Wielowątkowość ........................................................................................................... 287 Uwaga na aplikacje Javy z GUI (grubych klientów) ..................................................... 288 Zarządzanie konfiguracją środowisk ............................................................................. 289 Spis treści 11 AJAX — Asynchroniczny JavaScript i XML ............................................................... 290 Javadoc i komentarze ..................................................................................................... 290 Cały system w jednym pliku WAR ............................................................................... 291 Podsumowanie ............................................................................................................... 291 Rekomendowane źródła ................................................................................................ 292 Rozdział 11. Co dalej? ..................................................................................... 293 Co jest omawiane w tym rozdziale? .............................................................................. 294 Jak ukończyć aplikację Time Expression ...................................................................... 294 Metodologie XP i AMDD ............................................................................................. 295 Platforma Java ............................................................................................................... 295 Ant ................................................................................................................................. 295 JUnit ............................................................................................................................... 296 Hibernate ....................................................................................................................... 296 Spring Framework ......................................................................................................... 297 Eclipse SDK .................................................................................................................. 297 Zapis logów, debugowanie, monitorowanie i profilowanie .......................................... 298 Gdzie szukać pomocy? .................................................................................................. 299 Fora dyskusyjne ....................................................................................................... 299 Javadoc i kod źródłowy ........................................................................................... 299 Krótka uwaga na temat narzędzi do sprawdzania „jakości” kodu ................................. 300 Podsumowanie ............................................................................................................... 300 Rekomendowane źródła ................................................................................................ 301 Rozdział 12. Końcowe przemyślenia ................................................................. 303 Moje plany na najbliższą przyszłość ............................................................................. 304 Przyszłość, metodologia Agile, technologia Java ......................................................... 304 Wiwat! ........................................................................................................................... 305 Część IV Dodatki ...................................................................... 307 Dodatek A Kod źródłowy ................................................................................ 309 Współdzielony katalog bibliotek zewnętrznych ............................................................ 309 Katalog przykładowej aplikacji ..................................................................................... 310 Pliki Ant .................................................................................................................. 311 Pliki bazy danych HSQLDB ................................................................................... 311 Konfiguracja (pliki) Javy ........................................................................................ 311 Katalog przykładowej aplikacji — wersja po refaktoryzacji ........................................ 313 Integracja Spring i Hibernate — katalog przykładowej aplikacji ................................. 313 Dodatek B Kończymy refaktoryzować kod przykładowej aplikacji .................... 315 SignInController.java: monitorowanie JMX ................................................................. 315 TimesheetListController.java: monitorowanie JMX ..................................................... 316 Klasy zarządzające: integracja Spring i Hibernate ........................................................ 316 timesheetlist.jsp: przechodzimy na plik dołączany i bibliotekę Displaytag .................. 317 enterhours.jsp: przechodzimy na plik dołączany i bibliotekę znaczników Timex Tag ................................................................................................................... 318 Klasy *Test i TimexTestCase ........................................................................................ 318 DateUtil.java: nowa metoda .......................................................................................... 319 timex.css: nowe style ..................................................................................................... 319 timexhsqldb.xml: naprawiamy błąd w danych .............................................................. 319 12 Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse Dodatek C Konwencje pisania kodu w Javie ................................................... 321 Dodatek D Zabezpieczamy aplikację sieciową ................................................ 323 Dodatek E Ściągawka z przykładowego procesu wytwarzania oprogramowania ...325 Początki projektu ........................................................................................................... 325 Faza badań ..................................................................................................................... 326 Planowanie ..................................................................................................................... 326 Iteracyjne wytwarzanie oprogramowania ...................................................................... 326 Dodatek F Ściągawka z modelowania Agile .................................................... 327 Dodatek G Ściągawka z programowania ekstremalnego (XP) .......................... 329 Dodatek H Ciekawe narzędzia ........................................................................ 331 Narzędzia wieloplatformowe ......................................................................................... 331 Narzędzia dla Windows ................................................................................................. 332 Narzędzia dla Mac OS X ............................................................................................... 333 Narzędzia dla Linuksa (KDE) ....................................................................................... 333 Dodatek I Badania Visual Patterns ............................................................... 335 Definicja problemu ........................................................................................................ 335 Przeszłość: jak oszukiwaliśmy sami siebie ................................................................... 335 Przyszłość: metody Agile .............................................................................................. 337 Mój punkt widzenia ....................................................................................................... 338 BRUF i BDUF ......................................................................................................... 339 Terminologia ........................................................................................................... 339 Chcesz dołączyć do społeczności? ................................................................................ 339 Skorowidz .................................................................................... 341 Rozdział 3. ¨ Metodologie XP i AMDD 67 Rozdział 3. W tym rozdziale w końcu zabierzemy się za technologiczną stronę projektu, więc od teraz zaczyna się prawdziwa zabawa. W prawdziwie iteracyjnym środowisku programistycznym wszystkie zagadnienia doty- czące architektury i projektowania nie muszą być koniecznie definiowane na samym początku. Refaktoryzacja (poprawianie kodu bez naruszania funkcjonalności) odgrywa 68 Część II ¨ Tworzymy przykładową aplikację ważną rolę w stałej poprawie początkowo opracowanego projektu, ponieważ ciągle będziesz znajdował lepsze sposoby implementacji pewnych funkcji. Ponadto kiedy zakres projektu jest wstępnie zdefiniowany, to wymagania użytkownika mogą ciągle się rozwi- jać; jest to lepsze rozwiązanie niż blokowanie z góry jakichkolwiek zmian. Dobrym pomysłem, oprócz zmiennych wymagań, jest interakcja z użytkownikami, dająca możli- wość zadawania pytań. Chociaż część pracy może zostać wykonana na początku, na przykład historie użytkow- nika, wysokopoziomowa architektura, prototypy interfejsu użytkownika, model dome- nowy, standardy itd., to inne zagadnienia projektowe powinny być rozwiązane w ite- racji, która obejmuje dany problem. Ponadto, jak będziesz mógł zobaczyć w rozdziałach 5. i 7., wstępne pisanie testów może również pomóc w projektowaniu Twoich klas. Nie musisz więc mieć dopracowanych wszystkich szczegółów na samym początku; inaczej mówiąc, możesz stosować przy projektowaniu podejście „w locie” (ang. just-in-time). Jednakże należy opracować jakikolwiek wstępny projekt, być może w iteracji 0 (być może będziesz chciał zaprezentować dowód koncepcji projektu (ang. proof-of-concept), pokazać, jak technologie działają od początku do końca, od interfejsu użytkownika do bazy danych). Prawdopodobnie w iteracjach 1. i 2. zostanie zaimplementowana mniejsza liczba historii użytkownika, ponieważ potrzeba dodatkowego czasu na projekt i przygotowa- nie środowiska pracy — w tym model domenowy (omówiony później), definicje obiektów biznesowych, konwencje nazw Javy, proces (skrypt) budowania (integracji) wspólny dla zespołu itd. W tym rozdziale chcę pokazać od początku do końca metodologię AMDD (Agile Model Driven Development; agilemodeling.com) i metody programowania ekstremalnego (XP; extremeprogramming.org). Co jest omawiane w tym rozdziale? W tym rozdziale zrealizujemy założenia architektury i projektu przyjęte dla naszej przy- kładowej aplikacji Time Expression: t Przygotujemy diagram architektury. t Zbadamy obiekty, korzystając z kart CRC. t Opracujemy mapę witryny (diagram przepływu UI). t Wykonamy diagramy klas i pakietów dla Time Expression. t Założymy strukturę katalogów do przechowywania naszych plików (które utworzymy w kolejnych rozdziałach). t Przyjrzymy się krokom, które wykonamy w następnych rozdziałach w celu kompletnego oprogramowania naszych ekranów. Rozdział 3. ¨ Metodologie XP i AMDD 69 t Przejrzymy listę zaawansowanych pojęć, które będziemy musieli rozważyć, tworząc naszą przykładową aplikację: obsługa wyjątków, zadania zaplanowane, zarządzanie transakcjami, zapis logów i inne. Projektowanie i wybór artefaktów W poprzednim rozdziale przyjrzeliśmy się metodologii XP i jej zastosowaniu przy defi- niowaniu wymagań biznesowych i pracy z klientem. W tym rozdziale pójdziemy o krok dalej i opracujemy minimalną architekturę i projekt, aby ułatwić pracę przy tworzeniu Time Expression, korzystając z popularnych technologii: Hibernate, Spring Framework, Eclipse SDK i wielu innych związanych z nimi narzędzi, na przykład Anta, JUnit itp. Jeśli natknąłeś się na mit, że programiści XP nie projektują i nie dokumentują swojej pracy, to mam nadzieję, że zmienisz błędne zdanie na ten temat pod koniec rozdziału. Pozwól, że przedstawię Ci podstawowe informacje na ten temat. Spójrz na rysunek 3.1, który pokazuje kilka możliwych artefaktów, jakie możesz zreali- zować w kolejnej wersji lub iteracji. Artefakty na poziomie wydania są to te, które two- rzysz przed nowym wydaniem; analogicznie artefakty na poziomie iteracji są wytwarzane przed każdą iteracją. Nie jest to obowiązkowe dla każdego projektu, więc możemy wybrać i używać tego, czego naprawdę potrzebujemy. Jednakże pomiędzy rozdziałem 2., „Przykładowa aplikacja: Time Expression”, a tym rozdziałem zdecydowałem się zapre- zentować jak najwięcej praktycznych informacji o Time Expression. Na końcu tego rozdziału pokażę inny diagram, który będzie wiązać razem wszystkie artefakty, które powstały w wyniku naszych wysiłków pomiędzy poprzednim i tym rozdziałem (ale nie oszukuj i nie zaglądaj tam teraz, ponieważ jest to szczegółowy diagram i nie chciałbym Cię nim teraz przytłoczyć). Rysunek 3.1. XP (AMDD) — poziom wydania i poziom iteracji To, co zobaczysz w tym rozdziale, da Ci przynajmniej pewien punkt widzenia. Ten pro- ces może (lub też nie) zadziałać w Twoim przypadku. Jednakże muszą być jakieś pozy- tywne aspekty użycia tych metodologii, ponieważ deweloperzy uwielbiają je i widziałem wiele pomyślnie ukończonych projektów, które były wynikiem ich użycia. Ponadto w naszym przypadku artefakty przedstawione w tym rozdziale są istotne dla reszty tej książki i omówiony proces może nam tutaj pomóc. Jak widać na rysunku 3.1, mamy do stworzenia w tym rozdziale kilka artefaktów, więc zacznijmy pracę. Jednakże zanim zaczniemy, chciałbym dostarczyć dwóch punktów widzenia użytkowników XP. 70 Część II ¨ Tworzymy przykładową aplikację Szef projektu pracujący w firmie Fortune 50 powiedział mi ostatnio: „Kiedy zaczy- namy iterację, to pierwszy jej dzień zwykle spędzamy na przeglądaniu historii i dzie- leniu ich na zadania. Ćwiczenie polegające na dzieleniu zadań jest tak naprawdę sesją projektową. Na koniec widać, że około 20 czasu każdej iteracji deweloperzy poświę- cają na projektowanie. Jeśli dodasz czas wykorzystywany przez wszystkich dewelope- rów w czasie wszystkich iteracji, to otrzymasz dużą liczbę, która obala stwierdzenie «bez projektu»”. Aby dać Ci również inny punkt widzenia na metodologię XP, przedstawię rozważania starszego architekta, który od dłuższego czasu pracuje w branży IT i ukończył wiele projektów przy pomocy metodologii XP i AMDD: „Jest również inny poziom projekto- wania XP — dzienny. Refaktoryzacja jest częścią projektowania. Chociaż początkowy projekt iteracji jest ważnym krokiem, to projektowanie po napisaniu kodu tworzy różnice pomiędzy projektem dobrym a naprawdę eleganckim”. Różnice tkwiące w podejściu do XP dotyczą architektury i projektowania w całym pro- cesie wytwarzania, a nie tylko na początku projektu. Inaczej mówiąc, aplikacja ciągle ewoluuje w ciągu różnych iteracji. Korzyścią płynącą z takiego podejścia jest to, że pro- jektowanie dotyczy tego, co aktualnie tworzysz, a nie pochłania od trzech do sześciu miesięcy przed kodowaniem, w sytuacji gdy wymagania mogą ewoluować w dzisiejszym ciągle zmieniającym się świecie. Diagram architektury Rysunek 3.2 przedstawia diagram opisujący architekturę naszej przykładowej aplikacji. Zauważ, że został zmieniony na formę elektroniczną z wersji tablicowej, jaką widziałeś w poprzednim rozdziale. Konwersja na formę elektroniczną jest kwestią gustu; mógłbyś zrobić zdjęcie aparatem cyfrowym diagramu znajdującego się na tablicy, ale osobiście wolę jasne i czytelne diagramy. Rysunek 3.2. Diagram architektury dla Time Expression Architektura jest dosyć prosta. Mamy trzy standardowe warstwy architektury sieciowej z warstwą klienta (przeglądarka WWW), warstwą środkową (serwer aplikacji) i naszą warstwą danych (baza danych). Rozdział 3. ¨ Metodologie XP i AMDD 71 Ponadto używamy standardu model-widok-kontroler (MVC); jest to wzorzec projektowy stosowany w większości aplikacji sieciowych bazujących na języku Java. Kontroler jest punktem wejścia żądań sieciowych (HTTP), kontroluje widok i model. Model zaj- muje się danymi, które zostały uzyskane z kontrolera i są przekazywane do widoku, ten z kolei jest odpowiedzialny za wyświetlenie danych. W naszym przypadku widok stworzymy za pomocą JSP (JavaServer Pages). To, co czyni naszą architekturę interesującą, to nie fakt, że korzysta ze wzorca MVC, ale to, że warstwa środkowa zawiera Spring Framework i Hibernate, dwie technologie omówione szczegółowo w dalszej części tej książki. Hibernate, jak będziesz mógł zoba- czyć później, zapewnia proste utrwalanie obiektów w bazie danych, ponieważ pozwala traktować tabele i rekordy jak plain old Java objects (POJO). Spring Framework (springframework.org) dostarcza wielu korzyści, szczególnie jeśli pracujesz z obiektami POJO. Na przykład użyjemy Spring MVC jako naszego frameworka sieciowego, ponie- waż chcemy uczynić kod bardziej przejrzystym (w porównaniu na przykład ze Struts). Inną wartą uwagi cechą frameworka Spring jest wsparcie dla zadań zaplanowanych, nieza- leżnych od zewnętrznych usług, takich jak CRON w systemach uniksowych lub Harmo- nogram zadań w Windows. Oczywiście, główną zaletą jest dostarczana przez Spring funkcja odwrócenia kontroli (ang. inversion of control — IoC), o której dowiemy się więcej w dalszych rozdziałach. Od historii użytkownika do projektu Omówiliśmy różne historie użytkownika w rozdziale 2. Dla zachowania zwięzłości nie zaimplementujemy ich wszystkich w tej książce. Jednakże historie, które wybrałem, dostarczą Ci kompletnych, działających przykładów, obejmujących ekrany zarówno zawierające formularze, jak i niezawierające ich. Dodatkowo przyjrzymy się zawan- sowanym elementom takim jak implementacja zabezpieczeń za pomocą obiektów prze- chwytujących (ang. interceptors), wysyłanie e-maili i zadania zaplanowane, które doty- czą kilku historii omówionych w rozdziale 2. W dalszej części rozdziału dostarczę przykładów bazujących na dwóch historiach użytkownika, nazwanych w rozdziale 2. „Wprowadź godziny” i „Lista kart pracy”. Analizujemy klasy przy pomocy kart CRC Rysunek 3.3 pokazuje model domenowy wykonany w rozdziale 2. Model domenowy umożliwia nam analizę obiektów biznesowych lub domenowych. Historie użytkownika umożliwią nam analizę klas kontrolerów internetowego interfejsu użytkownika. Tak więc przyjrzyjmy się obiektom, które chcemy wykorzystać do implementacji historii „Lista arkuszy”, abyśmy mogli się dokładnie przyjrzeć, jak działają karty CRC. 72 Część II ¨ Tworzymy przykładową aplikację Rysunek 3.3. Model domenowy dla Time Expression Rysunek 3.4 pokazuje prototyp UI „Lista kart pracy” z rozdziału 2. Jak wspomniałem wcześniej, wiemy, że interfejs użytkownika będzie się opierał na przeglądarce WWW i że będziemy korzystać z wzorca MVC. Tak więc przyjrzyjmy się naszym klasom z punktu widzenia wzorca projektowego MVC. Rysunek 3.4. Ekran „Lista kart pracy W modelu znamy już nazwy niektórych obiektów Time Expression — znajdują się one w naszym modelu domenowym. Znamy również nazwę historii użytkownika dla kontrolera (w tym przypadku Lista kart pracy) z rozdziału 2. Wiedząc to wszystko, możemy zająć się naszymi pierwszymi klasami, korzystając z kart CRC. W tym przypadku karty CRC określają nazwę klasy, odpowiedzialność i klasy współ- pracujące. Tabela 3.1 pokazuje budowę przykładowej karty CRC wraz z wyjaśnieniami dotyczącymi trzech komponentów, które tam widać. Zauważ, że chociaż skorzystałem tutaj z wersji elektronicznej, to karty możesz wykonać z papieru o wymiarach 7×12 cm i później przetworzyć je na formę elektronicznej (jeśli okaże się to konieczne). Tabela 3.1. Budowa prostej karty CRC Nazwa klasy (rzeczownik) Odpowiedzialność (obowiązki tej klasy, metody biznesowe, obsługa wyjątków, metody związane z bezpieczeństwem, atrybuty, zmienne) Współpracownicy (inne klasy wymagane do dostarczenia kompletnego rozwiązania) Rozdział 3. ¨ Metodologie XP i AMDD 73 Karty CRC dostarczają nieformalnej techniki do zorientowanej obiektowo analizy interakcji zachodzących pomiędzy klasami. Lubię karty CRC, ponieważ mogą być użyte w nieformalnej sesji z deweloperami lub użytkownikami do analizy obiektów bez potrzeby użycia komputera. Ponadto karty CRC mogą być stosowane w celu utworzenia formalnego diagramu klas, jeśli będzie to konieczne (zrobimy do w dalszej części tego rozdziału). Tabele od 3.2 do 3.4 pokazują przykładowe karty CRC dla klas, które stworzymy później w tym rozdziale; zostały przedstawione tutaj, abyśmy mogli zapoznać się z wymaganiami dla ekranu Lista kart pracy. Tabela 3.2. Przykładowa karta CRC dla klasy Timesheet Timesheet Zna datę końca okresu Zna czas Zna kod działu Tabela 3.3. Przykładowa karta CRC dla klasy TimesheetManager TimesheetManager Pobiera kartę(y) pracy z bazy danych Zapisuje kartę pracy w bazie danych Tabela 3.4. Przykładowa karta CRC dla klasy TimesheetListController TimesheetListController Kontroler (ze wzoru MVC) służący do wyświetlania listy kart pracy Omówiliśmy podstawowe pojęcia związane z kartami CRC. Możemy teraz pójść krok dalej. Mapa przepływu aplikacji (artefakt domowej roboty) W starszych projektach korzystałem z tabeli podobnej do tabeli 3.5. Jej format opraco- wałem sam, nie jest on zdefiniowany. Nazwałem ją mapą przepływu aplikacji, ponie- waż pokazuje mi, w jaki sposób będzie działać interfejs użytkownika od początku do końca (jakimi ścieżkami może poruszać się użytkownik). Ta technika również dobrze odwzorowuje historie użytkownika na widoki (litera V we wzorcu MVC), które z kolei odwzorowuje na kontroler i ostatecznie na obiekty modelu. 74 Część II ¨ Tworzymy przykładową aplikację Tabela 3.5. Przykładowa mapa przepływu aplikacji Nazwa historii Lista kart pracy Wprowadź godziny Widok Klasa kontrolera Współpracownicy Zależne tabele timesheetlist TimeSheetListController TimesheetManager Timesheet enterhours EnterHoursController TimesheetManager Timesheet Department Technika uzupełniająca Porównując tę mapę przepływu aplikacji do diagramów klas lub kart CRC, zauważysz, że uzupełnia ona karty CRC i diagramy klas. Lista kart CRC, która zawiera między innymi zakres odpowiedzialności klas, uzupełnia braki mapy przepływu aplikacji. Z dru- giej strony diagramy klas pokazują związki, zachowania (metody), atrybuty i prawdopo- dobnie jeszcze więcej niż zawiera taka mapa. Przy połączeniu wszystkiego razem w postaci tabeli, możemy łatwo znaleźć nazwy klas (nawet przy dużych projektach) i łatwo je sortować przy pomocy arkusza kalkulacyjnego lub innych narzędzi. Rozszerzamy mapę przepływu aplikacji o kolumny CRUD Ta tabela może być również użyta do historii niezawierających interfejsu użytkownika, takich jak „Przypomnienie e-mailowe: Pracownik”. Na przykład kolumny odpowiedzialne za widok i kontroler mogą być zastąpione kolumną nazwaną „Zadanie”. Ponadto możesz rozszerzać tę tabelę, dzieląc kolumnę „Zależne tabele” na cztery kolumny CRUD (od ang. create — tworzenie, read — czytanie, update — aktualizacja, delete — usuwanie). To pozwoli pokazać nie tylko tabele, do których się odwołujemy, ale również to, w jaki sposób wpływają na nie poszczególne klasy. Dodając kolumny CRUD, zasad- niczo dostarczasz pełnej mapy przepływu (od widoku do bazy danych i z powrotem) w jednym wierszu naszej tabeli. UML — diagram klas W dalszej części zajmiemy się podstawowym diagramem klas. Moim zdaniem jest to opcjonalny krok (patrz ramka poniżej), ponieważ nasze karty CRC i mapa przepływu aplikacji dostarczą dostatecznej ilości informacji do implementacji klas. Jednakże dia- gramy klas mogą być dobrą rzeczą, kiedy użyjemy ich w odpowiedni sposób. Rysunek 3.5 pokazuje przykładowy i minimalny diagram klas dla klas zdefiniowanych do tej pory. Rozdział 3. ¨ Metodologie XP i AMDD 75 Rysunek 3.5. Przykładowy diagram klas dla Time Expression Osobista opinia: Diagramy UML Przez wiele lat używałem różnych rodzajów diagramów UML, włączając w to klasyczne diagramy UML, diagramy pakietów (moje ulubione) i rzadko używane diagramy wdrożenia. Jest również rodzaj diagramów, których nie jestem wielkim fanem: diagramy sekwencji. Nie lubię ich, ponieważ zauważyłem, że szybko stają się zbyt złożone i nieporęczne. Jednakże będę pierwszym, który Ci powie, że nie znam innego, lepszego sposobu niż te diagramy (w każdym razie jeszcze nie, ale pracuję obecnie nad lepszymi sposobami modelowania (tworzenia) dia- gramów. Sprawdź stronę visualpatterns.com, jeśli interesuje Cię ten temat). Tymczasem staram się używać diagramów UML wtedy, kiedy wydają się odpowiednie, ponie- waż myślę, że są cenne, gdy są użyte w odpowiednim miejscu i w odpowiednim czasie. W rzeczywistości sądzę, że diagramy UML są najbardziej użyteczne, kiedy są generowane do dokumentacji na postawie istniejącego już systemu (na przykład podczas przekazywania systemu). Mam nadzieję, że nie przedstawiłem UML w całkowicie złym świetle, bo nie to było moim celem, zwłaszcza że przez wiele lat wielu inteligentnych ludzi pracowało nad tym, aby powstał standard UML. (W rzeczywistości opieram całe moje badania na pracy wykonanej wcześniej, zamiast wymyślać od nowa koło). Moim głównym zarzutem wobec diagramów UML jest to, że stają się szybko zbyt skompli- kowane, szczególnie w przypadku dużych projektów. Innym problemem związanym z UML jest fakt, że wymaga specjalnych narzędzi, które są zwykle komercyjne i podnoszą koszty firmy. Dodatkowo niektóre z tych narzędzi mają stromą krzywą uczenia i w związku z tym wymagają specjalnego szkolenia pracowników (najlepszym przykładem jest Rational Rose), w wyniku czego znowu podnoszą się koszty utrzymania projektu. 76 Część II ¨ Tworzymy przykładową aplikację Ponadto proste narzędzia, takie jak OpenOffice.org, Microsoft PowerPoint, Microsoft Visio, umożliwiają łączenie różnych figur (na przykład prostokątów) za pomocą łączników, które są zachowywane nawet w przypadku zmiany położenia któregoś obiektu. Są to potężne narzędzia, ponieważ pozwalają w prosty sposób tworzyć diagramy przepływu. Często korzystam z łącz- ników, jak widać na diagramach umieszczanych w tej książce; w rzeczywistości prawie wszystkie diagramy zrobiłem, korzystając z OpenOffice.org! Ponadto często stosuję praktyki rekomendowane przez metodologię Agile, na przykład mode- lowanie w celu osiągnięcia określonego efektu lub tworzenie wystarczająco dobrych artefaktów. Idąc dalej, uaktualniam je tylko wtedy, gdy jest to niezbędne, ponieważ wiele artefaktów można wyrzucić, gdy spełnią swoje zadanie. Po zaimplementowaniu zaprojektowanego kodu posia- dasz już gotową dokumentację — tak, sam kod. (Jak wspominałem wcześniej, na podstawie kodu jesteśmy w stanie stworzyć niezłe diagramy klas i inne). Głównym powodem tego, że ciężka dokumentacja wydaje się czystym obłędem, jest to, iż nie jestem w stanie sobie przypomnieć projektu, który utrzymał do samego końca kompletną doku- mentację. Dzieje się tak, ponieważ w szybko zmieniającym się świecie, w którym zdarzają się nierealistyczne terminy ukończenia projektów, bardzo trudno jest utrzymać aktualną dokumen- tację. Podsumowując, używaj diagramów UML tam, gdzie są odpowiednie, ale nie wstydź się i nie wahaj użyć prostszych, lecz efektywniejszych własnych diagramów. Na koniec chciałem zacy- tować jedno z haseł reklamowych ze strony agilemodeling.com: „Twoim celem jest budowanie ogólnego zrozumienia, a nie tworzenie szczegółowej dokumentacj
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: