Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00158 013974 11052401 na godz. na dobę w sumie
J2EE. Podstawy programowania aplikacji korporacyjnych - książka
J2EE. Podstawy programowania aplikacji korporacyjnych - książka
Autor: Liczba stron: 480
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0211-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> j2ee - programowanie
Porównaj ceny (książka, ebook, audiobook).

Kompendium wiedzy dla każdego programisty, projektanta i kierownika projektu

Tworzenie aplikacji korporacyjnych to wyścig z czasem. Organizacje zmieniają się podobnie jak otoczenie biznesowe, w którym działają. Zbyt długi okres przygotowania aplikacji może sprawić, że po wdrożeniu okaże się ona bezużyteczna. Z drugiej jednak strony, zbyt duży pośpiech przy tworzeniu aplikacji powoduje, że pomija się fazę modelowania i testowania, pisząc kod źródłowy bez jakiejkolwiek koncepcji i planu. Efektem takiego pośpiechu są aplikacje niedostosowane do wymagań użytkowników i pracujące niestabilnie. Sposobem na stworzenie odpowiedniego systemu informatycznego dla korporacji jest wykorzystywanie odpowiednich metodyk projektowych i nowoczesnych narzędzi ułatwiających zarówno pisanie, jak i testowanie aplikacji.

Książka 'J2EE. Podstawy programowania aplikacji korporacyjnych' przedstawia najlepsze praktyki projektowe stosowane przy tworzeniu systemów informatycznych z wykorzystaniem platformy J2EE. Opisano w niej kolejne etapy projektu oraz narzędzia i metodyki, dzięki którym przeprowadzenie każdego z nich będzie szybsze i efektywniejsze. Czytając ją, poznasz metodyki RUP i XP, typy architektur systemów oraz sposoby modelowania aplikacji i narzędzia do automatycznego generowania szkieletu kodu źródłowego. Dowiesz się, jak optymalnie skonfigurować środowiska programistyczne i jak testować kolejne moduły aplikacji. Nauczysz się korzystać z nowoczesnych metodyk i narzędzi.

Wiadomości zawarte w tej książce sprawią, że będziesz w stanie szybciej projektować i tworzyć aplikacje korporacyjne.

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREŒCI SPIS TREŒCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOŒCIACH O NOWOŒCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl J2EE. Podstawy programowania aplikacji korporacyjnych Autor: Alan Monnox T³umaczenie: Miko³aj Szczepaniak ISBN: 83-246-0211-9 Tytu³ orygina³u: Rapid J2EE(TM) Development: An Adaptive Foundation for Enterprise Applications Format: B5, stron: 480 Kompendium wiedzy dla ka¿dego programisty, projektanta i kierownika projektu (cid:127) Nowoczesne metodyki wytwarzania oprogramowania (cid:129) Narzêdzia do modelowania aplikacji i automatycznego generowania kodu (cid:129) Koncepcja architektury sterowanej modelami (cid:129) Sposoby zapewnienia jakoœci aplikacji Tworzenie aplikacji korporacyjnych to wyœcig z czasem. Organizacje zmieniaj¹ siê podobnie jak otoczenie biznesowe, w którym dzia³aj¹. Zbyt d³ugi okres przygotowania aplikacji mo¿e sprawiæ, ¿e po wdro¿eniu oka¿e siê ona bezu¿yteczna. Z drugiej jednak strony, zbyt du¿y poœpiech przy tworzeniu aplikacji powoduje, ¿e pomija siê fazê modelowania i testowania, pisz¹c kod Ÿród³owy bez jakiejkolwiek koncepcji i planu. Efektem takiego poœpiechu s¹ aplikacje niedostosowane do wymagañ u¿ytkowników i pracuj¹ce niestabilnie. Sposobem na stworzenie odpowiedniego systemu informatycznego dla korporacji jest wykorzystywanie odpowiednich metodyk projektowych i nowoczesnych narzêdzi u³atwiaj¹cych zarówno pisanie, jak i testowanie aplikacji. Ksi¹¿ka „J2EE. Podstawy programowania aplikacji korporacyjnych” przedstawia najlepsze praktyki projektowe stosowane przy tworzeniu systemów informatycznych z wykorzystaniem platformy J2EE. Opisano w niej kolejne etapy projektu oraz narzêdzia i metodyki, dziêki którym przeprowadzenie ka¿dego z nich bêdzie szybsze i efektywniejsze. Czytaj¹c j¹, poznasz metodyki RUP i XP, typy architektur systemów oraz sposoby modelowania aplikacji i narzêdzia do automatycznego generowania szkieletu kodu Ÿród³owego. Dowiesz siê, jak optymalnie skonfigurowaæ œrodowiska programistyczne i jak testowaæ kolejne modu³y aplikacji. Nauczysz siê korzystaæ z nowoczesnych metodyk i narzêdzi. (cid:129) Podstawowe wiadomoœci o b³yskawicznym wytwarzaniu aplikacji (RAD) (cid:129) Metodyki projektowe Rational Unified Process (RUP) oraz Extreme Programming (XP) (cid:129) Wielowarstwowe architektury systemów (cid:129) Modelowanie systemów za pomoc¹ jêzyka UML (cid:129) Automatyczne generowanie kodu (cid:129) Stosowanie narzêdzi XDoclet i Hibernate (cid:129) Komunikacja z bazami danych (cid:129) Zasady programowania aspektowego (cid:129) Testowanie aplikacji Wiadomoœci zawarte w tej ksi¹¿ce sprawi¹, ¿e bêdziesz w stanie szybciej projektowaæ i tworzyæ aplikacje korporacyjne. Spis treści O autorze ....................................................................................... 13 Przedmowa ..................................................................................... 15 Część I Procesy adaptacyjne .....................................................21 Rozdział 1. Fundamenty adaptacyjne technologii J2EE ...................................... 23 Potrzeba błyskawicznego wytwarzania oprogramowania .............................................. 24 Wyzwania na poziomie przedsiębiorstw ........................................................................ 25 Platforma J2EE ............................................................................................................... 26 Definiowanie fundamentu adaptacyjnego ...................................................................... 27 Dlaczego fundament? ............................................................................................... 27 Dlaczego adaptacyjny? ............................................................................................. 27 Przygotowywanie fundamentów pod błyskawiczne wytwarzanie oprogramowania ...... 28 Ludzie ...................................................................................................................... 29 Narzędzia ................................................................................................................. 29 Szkielety ................................................................................................................... 29 Praktyki .................................................................................................................... 30 Standardy ................................................................................................................. 30 Procesy i procedury .................................................................................................. 30 Szkolenia .................................................................................................................. 30 Ustawiczne doskonalenie ......................................................................................... 31 Korzyści wynikające z inwestycji w fundamenty adaptacyjne ....................................... 32 Kluczowe czynniki decydujące o sukcesie ..................................................................... 33 Pozyskiwanie przychylności projektantów i programistów ..................................... 34 Edukacja ................................................................................................................... 35 Wsparcie zarządu ..................................................................................................... 36 Podsumowanie ............................................................................................................... 37 Informacje dodatkowe .............................................................................................. 38 Rozdział 2. Błyskawiczne wytwarzanie aplikacji ................................................. 39 Wspólne elementy koncepcji RAD ................................................................................ 40 Metoda skrzynki czasowej ....................................................................................... 40 Języki właściwe dla określonych dziedzin ............................................................... 41 Wielokrotne wykorzystywanie oprogramowania ..................................................... 42 Narzędzia zapewniające produktywność .................................................................. 44 Błyskawiczne tworzenie prototypów ....................................................................... 44 6 J2EE. Podstawy programowania aplikacji korporacyjnych Praca z prototypami ........................................................................................................ 45 Typy prototypów i techniki ich budowy .................................................................. 46 Wybór pomiędzy trybem odrzucania a trybem ewoluowania .................................. 48 Podsumowanie ............................................................................................................... 49 Informacje dodatkowe .............................................................................................. 49 Rozdział 3. Korzystanie z metod adaptacyjnych ................................................. 51 Po co w ogóle stosować metodyki? ................................................................................ 52 Metodyka RAD dla platformy J2EE ........................................................................ 52 Metody adaptacyjne kontra metody predyktywne .................................................... 53 Kaskadowy model cyklu życia projektu ......................................................................... 54 Klasyczny model kaskadowy ................................................................................... 54 Zalety i wady ............................................................................................................ 55 Studium przypadku .................................................................................................. 56 Wytwarzanie iteracyjne .................................................................................................. 59 Zalety podejścia iteracyjnego ................................................................................... 60 Procesy iteracyjne .................................................................................................... 63 Wprowadzenie do procesu RUP ..................................................................................... 63 Proces oparty na przypadkach użycia ....................................................................... 65 Iteracyjne wytwarzanie oprogramowania w ramach procesu RUP .......................... 68 Etapy procesu RUP .................................................................................................. 69 Dziedziny ................................................................................................................. 70 Elementy procesu RUP ............................................................................................ 72 Planowanie ............................................................................................................... 73 Wsparcie dla projektów na poziomie korporacyjnym .............................................. 75 Wady procesu RUP .................................................................................................. 75 Metody zwinne ............................................................................................................... 76 Wprowadzenie do metodyki XP ..................................................................................... 77 Praktyki procesu XP ................................................................................................. 77 Planowanie ............................................................................................................... 80 Projektowanie .......................................................................................................... 81 Kodowanie ............................................................................................................... 82 Testowanie ............................................................................................................... 84 Role w procesie XP .................................................................................................. 84 Stosowanie metodyki XP dla projektów korporacyjnych opartych na platformie J2EE ...................................................................................................................... 86 Podsumowanie ............................................................................................................... 88 Informacje dodatkowe .............................................................................................. 89 Część II Architektury zwinne ......................................................91 Rozdział 4. Projektowanie zapewniające błyskawiczność wytwarzania ................ 93 Cele architektur i projektów ........................................................................................... 94 Architektura i projekt w koncepcji RAD ........................................................................ 96 Wykorzystanie mocnych stron zespołu projektowego ............................................. 96 Wykorzystuj najlepsze dostępne szkielety ............................................................... 97 Myśl o przyszłości ................................................................................................. 100 Wystrzegaj się projektowania na rzecz wielokrotnego wykorzystywania kodu ..... 102 Stosowanie projektów prostopadłych ..................................................................... 103 Stosuj architektury wielowarstwowe ...................................................................... 104 Różne podejścia do architektury J2EE ......................................................................... 106 Architektury dwuwarstwowe kontra architektury wielowarstwowe ...................... 106 Enterprise JavaBeans ............................................................................................. 108 Perspektywy klientów zdalnych i lokalnych .......................................................... 109 Spis treści 7 Rozproszone komponenty ...................................................................................... 110 Wybór właściwego projektu ................................................................................... 113 Architektura zorientowana na interfejs WWW ...................................................... 113 Architektura zorientowana na komponenty EJB .................................................... 116 Podsumowanie ............................................................................................................. 118 Informacje dodatkowe ............................................................................................ 119 Rozdział 5. Oprogramowanie modelujące ......................................................... 121 Po co w ogóle modelować? .......................................................................................... 122 Komunikacja .......................................................................................................... 122 Weryfikacja poprawności ....................................................................................... 124 Perspektywy architektury ............................................................................................. 125 Zunifikowany język modelowania (UML) ..................................................................... 126 Diagramy przypadków użycia ................................................................................ 127 Diagramy aktywności ............................................................................................. 129 Diagramy klas ........................................................................................................ 130 Diagramy interakcji ................................................................................................ 132 Diagramy stanów ................................................................................................... 134 Diagramy wdrożenia i diagramy komponentów ..................................................... 135 Najczęstsze błędy ......................................................................................................... 135 Oprogramowanie tworzone w warunkach kultu cargo ........................................... 137 Narzędzia modelujące .................................................................................................. 137 Wybór narzędzia modelującego ............................................................................. 138 Obsługa języka UML ............................................................................................. 139 Sprawdzanie poprawności modelu ......................................................................... 140 Inżynieria normalna i inżynieria odwrotna ............................................................. 140 Obsługa wzorców projektowych ............................................................................ 142 Dlaczego narzędzia projektowe nie zdają egzaminu? ................................................... 145 Syndrom szczeniaka pod choinką .......................................................................... 145 Metody skutecznego korzystania z narzędzi modelujących ......................................... 148 Podsumowanie ............................................................................................................. 150 Informacje dodatkowe ............................................................................................ 150 Rozdział 6. Generowanie kodu ........................................................................ 153 Czym właściwie jest generowanie kodu? ..................................................................... 154 Pasywne generatory kodu ............................................................................................. 155 Generowanie kodu za pomocą narzędzia Apache Velocity .................................... 156 Zalety pasywnego generowania kodu .................................................................... 159 Aktywne generatory kodu ............................................................................................ 160 Zalety aktywnego generowania kodu ..................................................................... 160 Aktywne generatory kodu i wzorce kodu ............................................................... 162 Programowanie atrybutowe .......................................................................................... 163 Czym są atrybuty? .................................................................................................. 163 Atrybuty kontra dyrektywy preprocesora ............................................................... 164 Przypisy platformy J2SE 5.0 kontra atrybuty ......................................................... 165 Wprowadzenie do narzędzia XDoclet .......................................................................... 166 Instalacja narzędzia XDoclet .................................................................................. 167 Przygotowywanie pliku kompilacji narzędzia Ant ................................................. 167 Utworzenie komponentu sesyjnego ........................................................................ 171 Praca z aktywnie generowanym kodem ....................................................................... 177 Wskazówki dotyczące generowania kodu .............................................................. 177 Podsumowanie ............................................................................................................. 181 Informacje dodatkowe ............................................................................................ 181 8 J2EE. Podstawy programowania aplikacji korporacyjnych Rozdział 7. Błyskawiczność a bazy danych ...................................................... 183 Problem baz danych ..................................................................................................... 184 Dane są cenną wartością korporacji ....................................................................... 184 Problem odwzorowania obiektowo-relacyjnego .................................................... 187 Możliwości w zakresie dostępu do danych ................................................................... 190 Interfejs Java Database Connectivity (JDBC) ........................................................ 191 Narzędzia do odwzorowywania obiektowo-relacyjnego ........................................ 192 Komponenty encyjne ............................................................................................. 194 Obiekty danych Javy .............................................................................................. 196 Generowanie kodu i odwzorowywanie obiektowo-relacyjne ....................................... 197 Wprowadzenie do narzędzia Hibernate .................................................................. 198 Wprowadzenie do narzędzia Middlegen ................................................................ 199 Przygotowanie bazy danych ......................................................................................... 200 Wprowadzenie do systemu MySQL ....................................................................... 201 Utworzenie schematu bazy danych ........................................................................ 201 Uruchamianie skryptu bazy danych ....................................................................... 204 Generowanie warstwy utrwalania danych .................................................................... 204 Uruchamianie narzędzia Middlegen z poziomu programu Ant .............................. 206 Graficzny interfejs użytkownika programu Middlegen .......................................... 207 Dokumenty odwzorowania obiektowo-relacyjnego narzędzia Hibernate .............. 208 Od dokumentów odwzorowań do kodu źródłowego Javy ...................................... 212 Dokończenie całego procesu .................................................................................. 213 Podsumowanie ............................................................................................................. 215 Informacje dodatkowe ............................................................................................ 216 Rozdział 8. Architektura sterowana modelami ................................................. 217 Założenia technologii MDA ......................................................................................... 217 Wyjaśnienie podstawowych założeń koncepcji architektury sterowanej modelami ..... 219 Platforma ................................................................................................................ 220 Modele ................................................................................................................... 220 Odwzorowanie ....................................................................................................... 223 Architektura MDA kontra tradycyjne techniki modelowania ....................................... 224 Zalety ..................................................................................................................... 225 Wady ...................................................................................................................... 227 Narzędzia zgodne z architekturą MDA ........................................................................ 229 Wprowadzenie do narzędzia AndroMDA .............................................................. 230 Architektura MDA i program AndroMDA ................................................................... 230 Wymiana modeli reprezentowanych w formacie XMI ........................................... 232 Znaczniki modelu PIM ........................................................................................... 233 Wymienne wkłady MDA ....................................................................................... 236 Budowa wymiennego wkładu ................................................................................ 238 Szablony wymiennych wkładów MDA .................................................................. 240 AndroMDA w praktyce .......................................................................................... 242 AndroMDA 3.0 ...................................................................................................... 244 Podsumowanie ............................................................................................................. 244 Informacje dodatkowe ............................................................................................ 245 Języki błyskawicznego wytwarzania oprogramowania ....247 Część III Rozdział 9. Skrypty ........................................................................................ 249 Po co w ogóle używać języków skryptowych? ............................................................ 249 Cechy języków skryptowych ........................................................................................ 251 Doświadczenie zespołu projektowego ................................................................... 251 Wieloplatformowość .............................................................................................. 252 Integracja z klasami Javy ....................................................................................... 252 Spis treści 9 Wprowadzenie do języka Jython .................................................................................. 253 Instalacja Jythona ................................................................................................... 255 Uruchamianie skryptów ......................................................................................... 255 Język Jython ........................................................................................................... 256 Integracja z językiem Java ..................................................................................... 258 Tworzenie prototypów interfejsu użytkownika ...................................................... 261 Tworzenie serwletów w języku Jython .................................................................. 262 Alternatywa — język Groovy ...................................................................................... 264 Podsumowanie ............................................................................................................. 265 Informacje dodatkowe ............................................................................................ 265 Rozdział 10. Praca z regułami ........................................................................... 267 Reguły biznesowe ........................................................................................................ 267 Czym jest reguła biznesowa? ................................................................................. 268 Struktura reguły biznesowej ................................................................................... 268 Dynamiczna natura reguł biznesowych .................................................................. 269 Reguły biznesowe w oprogramowaniu ......................................................................... 269 Reguły definiowane z góry .................................................................................... 270 Język definiowania reguł ........................................................................................ 270 Ścisłe wiązanie logiki systemowej z logiką biznesową .......................................... 270 Powielanie reguł ..................................................................................................... 271 Mechanizmy regułowe ................................................................................................. 271 Systemy regułowe .................................................................................................. 272 Mechanizmy regułowe w systemach korporacyjnych ............................................ 273 Wprowadzenie do języka Jess ...................................................................................... 274 Instalacja Jessa ....................................................................................................... 275 Przykład użycia języka Jess ................................................................................... 275 Jess i Java ............................................................................................................... 279 Interfejs API mechanizmu regułowego Javy ................................................................ 282 Mechanizmy regułowe stosowane na poziomie korporacyjnym .................................. 283 Cechy korporacyjnych mechanizmów regułowych ................................................ 284 Kryteria oceny mechanizmów regułowych ............................................................ 286 Podsumowanie ............................................................................................................. 287 Informacje dodatkowe ............................................................................................ 288 Rozdział 11. Programowanie aspektowe ........................................................... 289 Dlaczego programowanie aspektowe? ......................................................................... 290 Obszary przecinające ............................................................................................. 290 Mieszanie i rozpraszanie kodu ............................................................................... 291 Tradycyjne podejścia do problemu obszarów przecinających ................................ 292 Wyjaśnienie koncepcji programowania aspektowego .................................................. 295 Pojęcia i terminologia ............................................................................................ 295 Garbaci i smoki ...................................................................................................... 297 Metody tkania ........................................................................................................ 297 Wprowadzenie do narzędzia AspectJ ........................................................................... 298 AspectJ i Eclipse .................................................................................................... 299 Kompilator języka AspectJ .................................................................................... 299 Przykład użycia języka AspectJ ............................................................................. 300 Język kontra szkielet .................................................................................................... 306 Implementacje szkieletu programowania aspektowego ......................................... 307 Wprowadzenie do szkieletu AspectWerkz ................................................................... 308 Definicja aspektu w formacie XML ....................................................................... 309 Aspekty w postaci przypisów metadanych ............................................................. 310 Opcje tkania w szkielecie AspectWerkz ................................................................ 311 Aspektowe oprogramowanie pośredniczące .......................................................... 312 10 J2EE. Podstawy programowania aplikacji korporacyjnych Wdrażanie aspektów ..................................................................................................... 313 Aspekty wytwarzania ............................................................................................. 313 Aspekty produkcyjne ............................................................................................. 314 Programowanie aspektowe w zestawieniu z innymi koncepcjami wytwarzania oprogramowania ......................................... 315 Podsumowanie ............................................................................................................. 316 Informacje dodatkowe ............................................................................................ 317 Część IV Środowiska dynamiczne ..............................................319 Rozdział 12. Optymalne kompilowanie systemów .............................................. 321 Czas i ruch .................................................................................................................... 322 Linia produkcji oprogramowania ........................................................................... 322 Czas i ruch w kontekście wytwarzania oprogramowania ....................................... 323 Proces kompilacji ......................................................................................................... 323 Projektowanie procesu kompilacji ......................................................................... 324 Wymagania platformy J2EE w zakresie kompilacji ............................................... 325 Czym jest wdrażanie „na gorąco”? ........................................................................ 327 Wprowadzenie do narzędzia Ant .................................................................................. 328 Kompilacje minimalne w programie Ant ..................................................................... 330 Znaczenie zależności kompilacji ............................................................................ 330 Definiowanie zależności kompilacji w plikach Anta ............................................. 333 Praca z podprojektami .................................................................................................. 336 Przeglądanie zależności kompilacji .............................................................................. 337 Standardowe zadania kompilacji .................................................................................. 339 Organizacja projektu .................................................................................................... 341 Katalog źródłowy (source) ..................................................................................... 341 Katalog bibliotek (lib) ............................................................................................ 343 Katalog plików skompilowanych (build) ............................................................... 343 Katalog plików gotowych do wdrożenia ................................................................ 344 Integracja ze środowiskami IDE ................................................................................... 345 Rozszerzanie Anta o obsługę języka Jython ................................................................. 347 Tworzenie nowego zadania Anta ........................................................................... 347 Kompilowanie klas Jythona ................................................................................... 348 Testowanie nowego zadania ................................................................................... 349 Podsumowanie ............................................................................................................. 350 Informacje dodatkowe ............................................................................................ 350 Rozdział 13. Zintegrowane środowisko wytwarzania .......................................... 353 Po co używać zintegrowanego środowiska wytwarzania? ............................................ 354 Podstawowe funkcje środowisk IDE ...................................................................... 354 Wprowadzenie do platformy Eclipse ............................................................................ 358 Czym jest Eclipse? ................................................................................................. 358 Instalacja i uruchamianie środowiska Eclipse ........................................................ 359 Obszar roboczy platformy Eclipse ......................................................................... 360 Platforma Eclipse jako warsztat pracy programisty ............................................... 360 Rozszerzanie warsztatu pracy za pomocą dodatkowych modułów ........................ 362 Funkcjonalność środowisk IDE w kontekście wytwarzania oprogramowania korporacyjnego .......................................................................................................... 364 Kreatory kodu ........................................................................................................ 365 Obsługa edycji wielu typów plików ....................................................................... 367 Integracja z narzędziem Ant ................................................................................... 369 Praca z generatorami kodu ..................................................................................... 370 Spis treści 11 Sterowanie pracą serwera i wdrażanie aplikacji ..................................................... 372 Obsługa technik modelowania ............................................................................... 374 Dostęp do bazy danych .......................................................................................... 374 Diagnozowanie aplikacji J2EE w ramach platformy Eclipse ....................................... 375 Architektura programu uruchomieniowego platformy Javy (JPDA) ...................... 376 Diagnozowanie aplikacji J2EE ............................................................................... 378 Wymiana „na gorąco” ............................................................................................ 380 Diagnozowanie stron JSP ....................................................................................... 382 Wskazówki dotyczące diagnozowania aplikacji .................................................... 382 Podsumowanie ............................................................................................................. 385 Informacje dodatkowe ............................................................................................ 385 Rozdział 14. Wytwarzanie sterowane testami .................................................... 387 Testowanie jako część procesu wytwarzania ................................................................ 388 Zalety wytwarzania sterowanego testami ............................................................... 389 Koszt wytwarzania sterowanego testami ................................................................ 390 Wprowadzenie do narzędzia JUnit ............................................................................... 391 Wykonywanie testów szkieletu JUnit w środowisku Eclipse ................................. 395 Generowanie testów jednostkowych ............................................................................ 397 Generowanie testów jednostkowych w środowisku Eclipse .................................. 397 Testy jednostkowe i architektura MDA ................................................................. 400 Generowanie przypadków testowych ..................................................................... 401 Testowanie „od podszewki” ......................................................................................... 403 Czym jest obiekt pozorny? ..................................................................................... 404 Praca z obiektami pozornymi ................................................................................. 406 Rodzaje obiektów pozornych ................................................................................. 406 Ratunek w postaci dynamicznych obiektów pozornych ......................................... 407 Wybór pomiędzy statycznymi a dynamicznymi obiektami pozornymi .................. 411 Podsumowanie ............................................................................................................. 412 Informacje dodatkowe ............................................................................................ 413 Rozdział 15. Efektywne zapewnianie jakości ..................................................... 415 Zapewnianie jakości ..................................................................................................... 416 Środowisko projektowe .......................................................................................... 417 Proces testowania ................................................................................................... 418 Testowanie projektów RAD ................................................................................... 419 Automatyzacja testów .................................................................................................. 420 Testowanie rozwiązań J2EE ................................................................................... 422 Narzędzia automatyzujące testy ............................................................................. 423 Testy funkcjonalne ....................................................................................................... 425 Wprowadzenie do narzędzia HttpUnit .......................................................................... 426 HttpUnit i JUnit ...................................................................................................... 427 Pisanie testów z wykorzystaniem interfejsu HttpUnit API .................................... 427 Testy obciążeniowe i wytrzymałościowe ..................................................................... 431 Problematyka wydajności ...................................................................................... 432 Wprowadzenie do narzędzia JMeter ............................................................................. 432 Testowanie aplikacji MedRec za pomocą szkieletu JMeter ................................... 433 Tworzenie grupy wątków ....................................................................................... 435 Element konfiguracyjny ......................................................................................... 436 Kontrolery logiczne ................................................................................................ 437 Elementy próbkujące .............................................................................................. 439 Elementy nasłuchujące ........................................................................................... 442 Wykonywanie planu testu ...................................................................................... 443 Analiza wyników ................................................................................................... 443 12 J2EE. Podstawy programowania aplikacji korporacyjnych Wskazówki dotyczące korzystania ze szkieletu JMeter ............................................... 445 Podsumowanie ............................................................................................................. 447 Informacje dodatkowe ............................................................................................ 448 ...................................................................................449 Dodatki Dodatek A Akronimy ...................................................................................... 451 Dodatek B Bibliografia ................................................................................... 455 Skorowidz ..................................................................................... 459 Rozdział 12. Optymalne kompilowanie systemów Jednym z pierwszych zadań, które będziesz musiał zrealizować w fazie konstruowania projektu, będzie właściwe zaplanowanie i przygotowanie środowiska pracy dla zespołu projektowego. Dobrze zaprojektowane środowisko jest podstawowym warunkiem zapew- nienia produktywności i efektywności całego zespołu projektowego. W niniejszym rozdziale skupimy się tylko na jednym aspekcie środowiska wytwa- rzania — przedmiotem analizy będzie proces kompilacji, który jest kluczowym czynni- kiem decydującym o możliwości błyskawicznego wytwarzania aplikacji. Szczegółowo omówimy wagę szybkiego, precyzyjnego i dającego możliwość zarządzania procesu kompilacji i przeanalizujemy techniki korzystania z narzędzia Apache Ant w zakresie konstruowania optymalnych środowisk kompilacji dla aplikacji platformy J2EE. W rozdziale omówimy szereg zagadnień związanych z procesem budowy w ramach projektów błyskawicznego wytwarzania oprogramowania: (cid:141) Znaczenie efektywnych mechanizmów kompilacji w procesie błyskawicznego wytwarzania aplikacji. (cid:141) Zalety programu Ant jako narzędzia obsługującego kompilację. (cid:141) Sposoby wykorzystywania zależności kompilacji do ograniczania czasu potrzebnego do kompilacji. (cid:141) Zastosowanie narzędzia Antgraph (oferowanego z otwartym dostępem do kodu źródłowego), które umożliwia graficzne przeglądanie zależności zadeklarowanych w plikach Anta. (cid:141) Wskazówki dotyczące organizowania artefaktów kodu składających się na projekty J2EE. (cid:141) Najczęściej spotykane dobre praktyki korzystania z narzędzia Ant. 322 Część IV ♦ Środowiska dynamiczne Na końcu tego rozdziału ponownie przeanalizujemy język skryptowy Jython i zade- monstrujemy sposób, w jaki skrypty tego języka mogą być wykorzystywane do rozsze- rzania funkcjonalności Anta. Czas i ruch Każdy, kto kiedykolwiek miał okazję pracować przy linii produkcyjnej w zakładzie przemysłowym, doskonale zna pojęcie czasu i ruchu (ang. time and motion). Analiza czasu i ruchu obejmuje między innymi przegląd operacji potrzebnych do wytworzenia produktu w fabryce, a jej celem jest ograniczenie czasu produkcji i — tym samym — poprawa wydajności linii produkcyjnej. Taka analiza musi dotyczyć wszystkich kroków procesu wytwarzania, ponieważ tylko takie rozwiązanie pozwoli zidentyfikować wszyst- kie czynniki obniżające wydajność zakładu. Linia produkcyjna musi być wzorem efektywności, natomiast inżynierowie odpowie- dzialni za przebieg produkcji powinni wykorzystywać analizy czasu i ruchu podczas optymalizowania procesu produkcji. Wyobraź sobie linię produkcji samochodów, gdzie ogromna liczba budowanych aut przesuwa się na gigantycznej taśmie. Jeśli choć jeden krok tego procesu nie będzie realizowany w sposób optymalny, może się okazać, że nie tylko wzrasta koszt wyprodukowania każdego z samochodów, ale też spada liczba pojazdów wprowadzanych przez firmę na rynek. Czas produkcji nie jest jedynym kryterium, którym powinni się kierować inżynierowie odpowiedzialni za funkcjonowanie takiej linii. Innym ważnym elementem jest jakość — proces musi gwarantować satysfakcjonujący i w miarę stały poziom jakości każdego z towarów opuszczających linię produkcyjną. Chociaż analiza czasu i ruchu jest techniką wykorzystywaną przede wszystkim w za- kładach produkcyjnych, podobne podejście (przede wszystkim skupianie uwagi inżyniera produkcji na efektywności) równie dobrze mogłoby znaleźć zastosowanie w przypadku takich zadań jak projektowanie procesu kompilacji oprogramowania. Linia produkcji oprogramowania Niewiele osób dostrzega podobieństwa pomiędzy procesami wytwarzania oprogramo- wania a funkcjonowaniem linii produkcyjnych w zakładach przemysłowych. Wytwa- rzanie oprogramowania jest zadaniem wymagającym nie tylko twórczego myślenia, ale też nieco innego podejścia do każdego budowanego systemu. Okazuje się jednak, że pewne działania składające się na projekt informatyczny są często powtarzane (nawet codziennie) niemal przez wszystkich członków zespołu. Do zadań inżyniera oprogramowania należą tak naturalne czynności jak pobieranie najnowszej wersji aplikacji z systemu kontroli wersji kodu źródłowego, kompilowanie, wdrażanie i testowanie nowej funkcjonalności aplikacji oraz przeglądanie dziennika zda- rzeń w poszukiwaniu błędów, które ujawniły się w systemie od ostatniego cyklu. Te i wiele innych zadań składają się na typowy dzień pracy niemal każdego programisty. Rozdział 12. ♦ Optymalne kompilowanie systemów 323 Podobne, wielokrotnie powtarzane zadania są realizowane także przez inne osoby za- angażowane. Zespół odpowiedzialny za zapewnianie jakości regularnie wykonuje proces instalowania najnowszej wersji przekazanej przez zespół programistów i przygotowy- wania odpowiednich środowisk dla przyszłych testów. Taki zespół może realizować te zadania ręcznie lub z wykorzystaniem skryptów tworzących nowe, „czyste” środo- wisko dla każdego cyklu testowego. Aby było możliwe błyskawiczne wytwarzanie aplikacji, wszystkie te działania muszą być wykonywane efektywnie i bez zakłóceń. Czas i ruch w kontekście wytwarzania oprogramowania Środowisko wytwarzania oprogramowania oraz stosowane w nim procesy i procedury muszą gwarantować wszystkim członkom zespołu projektowego warunki do wygodnej i efektywnej pracy. Aby osiągnąć ten optymalny model realizacji projektu, zaangażo- wane zespoły powinny stosować praktyki bardzo podobne do tych właściwych dla in- żynierów w zakładach produkcyjnych — powinny wykonywać własne analizy czasu i ruchu w zakresie tych czynności, które są wykonywane odpowiednio często. Nie chodzi oczywiście o zatrudnianie inżynierów z doświadczeniem w przemyśle, którzy z zegarkiem w ręku będą pilnowali należytego zaangażowania i produktywności programistów. Za zapewnianie właściwej efektywności powinni odpowiadać wszyscy członkowie zespołu projektowego — każdy z nich musi stale poszukiwać sposobów na udoskonalanie procesów. Uwzględnianie w praktykach wytwarzania oprogramowania wniosków zgłaszanych przez projektantów i programistów ma kluczowe znaczenie dla utrzymania właściwego fundamentu adaptacyjnego pod błyskawiczne wytwarzanie oprogramowania, ponieważ tylko przez udoskonalanie tego procesu z projektu na projekt można osiągnąć produk- tywne środowiska pracy dla przyszłych aplikacji. Skoro mamy już świadomość znaczenia czasu i ruchu, przejdźmy do analizy niełatwych zagadnień związanych z procesem kompilacji. Proces kompilacji Dobry proces kompilacji powinien być czymś więcej niż tylko pojedynczym skryptem automatyzującym kompilowanie oprogramowania. Proces kompilacji powinien automa- tyzować wiele typowych i powtarzalnych czynności wykonywanych w ramach projektu. Do przykładów takich czynności należą: (cid:141) pobieranie kodu z systemu kontroli wersji, (cid:141) instalacja odpowiednich wersji bibliotek i oprogramowania, 324 Część IV ♦ Środowiska dynamiczne (cid:141) kompilacja bibliotek i komponentów aplikacji, (cid:141) uruchamianie zautomatyzowanych pakietów testowych, (cid:141) generowanie dokumentacji w standardzie JavaDoc, (cid:141) upakowanie komponentów i bibliotek w skompresowanych pakietach, (cid:141) konfiguracja środowisk wytwarzania i testowania systemu, włącznie z aktualizacją schematów wykorzystywanych baz danych i przygotowaniem danych testowych, (cid:141) wdrażanie aplikacji w środowisku wytwarzania, (cid:141) tworzenie kolejnych wersji komponentów programowych, (cid:141) wdrażanie budowanych wersji w środowisku testowym. Przygotowanie takiego procesu kompilacji jeszcze przed przystąpieniem do właściwej realizacji projektu może się przyczynić do znacznych oszczędności czasowych. Procesy kompilacji zwykle mają postać wyrafinowanych narzędzi, które wymagają uważnego zaprojektowania, skonstruowania i przetestowania. Oznacza to, że inwestycja w pro- cesy wytwarzania i kompilacji (które będą później wykorzystywane w wielu projek- tach) jest kluczowym czynnikiem decydującym o kształcie fundamentu adaptacyjnego pod błyskawiczne wytwarzanie oprogramowania. W następnym punkcie przedstawimy kilka wskazówek odnośnie tworzenia procesu kompilacji, który ułatwi realizację z najlepszych praktyk błyskawicznego wytwarzania oprogramowania. Projektowanie procesu kompilacji Tak jak budowane systemy informatyczne, także systemy kompilacji wymagają prze- prowadzenia fazy projektowania. Niezależnie od rodzaju wytwarzanego oprogramowania, znaczenie systemu kompilacji jest cechą wspólną wielu projektów. Poniżej wymieniono i krótko opisano kilka najważniejszych wymagań w tym zakresie: Dokładność Proces kompilacji musi w sposób logiczny i spójny łączyć kompilacje — prowadzić do generowania takich samych wyników na żądanie wszystkich programistów zaangażowanych w prace nad projektem dla tego samego zbioru plików źródłowych. Błyskawiczność Skoro kompilacje są wykonywane często i w regularnych odstępach czasu, proces musi być na tyle zoptymalizowany, aby wyeliminować ryzyko niepotrzebnego tracenia czasu na realizację tego procesu. Automatyzacja Wszystkie kroki procesu kompilacji muszą być kontrolowane przez odpowiednie narzędzia, które zapewniają jego całkowitą automatyzację. Jeśli programiści będą musieli wykonywać pewne kroki (np. kopiowania Rozdział 12. ♦ Optymalne kompilowanie systemów 325 plików lub kompilowania poszczególnych modułów) samodzielnie, ryzyko popełnienia błędów w tym procesie będzie znacznie wyższe. Co więcej, brak pełnej automatyzacji wyklucza możliwość kompilacji oprogramowania poza godzinami pracy, np. w nocy. Standaryzacja Sposób stosowania procesu kompilacji w kolejnych projektach realizowanych przez dany zespół powinien być identyczny lub bardzo podobny. Parametryczność Kompilacja przeprowadzana na potrzeby programisty najprawdopodobniej będzie się nieznacznie różnić od tej realizowanej z myślą o środowisku formalnych testów. Tego typu rozbieżności mogą się sprowadzać do odpowiednich opcji kompilatora lub pomijania pewnych kroków kompilacji. Proces kompilacji musi umożliwiać generowanie systemów w wersjach właściwych dla każdego z typów środowisk. Możliwość konserwacji We współczesnych środowiskach kompilacji można zaobserwować tendencję do zwiększania rozmiaru i poziomu wyrafinowania do punktu, w którym ich konserwacja staje się poważnym problemem (nie wspominając już o wydłużonym czasie konfiguracji tych środowisk). System kompilacji musi z jednej strony zapewniać prostotę konserwacji, z drugiej zaś powinien obsługiwać nawet najbardziej skomplikowane zadania kompilacji. Okazuje się niestety, że te dwa wymagania bywają sprzeczne. Opisane powyżej wymagania dotyczą większości projektów polegających na wytwa- rzaniu oprogramowania. Wytwarzanie oprogramowania korporacyjnego wprowadza do- datkowy zbiór wymagań specyficznych dla platformy J2EE. Wymagania platformy J2EE w zakresie kompilacji Proces kompilacji w przypadku konwencjonalnej aplikacji Javy dotyczy zwykle prostej struktury budowanej z myślą o pojedynczym komputerze klienta, zatem nie wymaga skomplikowanego środowiska kompilacji. Tego samego nie można niestety powiedzieć o aplikacjach platformy J2EE, w przypadku których proces kompilacji składa się z wielu zawiłych kroków prowadzących do generowania modułów dla wielu docelo- wych komputerów. W przeciwieństwie do programów platformy J2SE aplikacja J2EE składa się ze zbioru komponentów, które dopiero razem tworzą system informatyczny. Każdy z tych kompo- nentów może wprowadzać własne, nieraz bardzo zróżnicowane wymagania w zakresie kompilacji. Komponenty EJB wymagają takich wyspecjalizowanych zadań kompilacji jak generowanie implementacji obiektów pośredniczących i szkieletów. Z uwagi na oferowane oszczędności czasowe stale rośnie popularność automatycznych generatorów kodu (np. popularnego XDocleta), warto jednak pamiętać, że ich stosowanie oznacza dodatkowe kroki w procesie kompilacji i — tym samym — podnosi poziom złożoności tego procesu. 326 Część IV ♦ Środowiska dynamiczne Narzędzie XDoclet omówiono w rozdziale 6. Poza tymi wyspecjalizowanymi zadaniami, komponenty J2EE wymagają tzw. upa- kowania (ang. packaging). Komponenty EJB należy umieszczać w archiwach Javy (ang. Java archive — JAR), natomiast aplikacje internetowe są upakowywane w archi- wach internetowych (ang. Web archive — WAR). Na koniec wszystkie komponenty można jeszcze zebrać w jednym pliku zasobów korporacyjnych (ang. Enterprise Re- source — EAR), czyli pliku zgodnym z formatem obsługiwanym przez serwery apli- kacji (takie rozwiązanie bardzo ułatwia wdrażanie aplikacji J2EE). Podsumowując, kompilacja oprogramowania dla platformy J2EE zwykle obejmuje na- stępujące zadania (których wykonywanie nie jest konieczne w przypadku tradycyjnych aplikacji Javy): (cid:141) uruchomienie generatorów kodu, (cid:141) przeprowadzenie wyspecjalizowanej kompilacji stosowanych komponentów (np. Enterprise JavaBeans), (cid:141) upakowanie (w plikach JAR, WAR i EAR), (cid:141) wdrożenie. Wszystkie te zadania wymagają czasu. Procesem szczególnie kosztownym czasowo jest upakowywanie, które wymaga przeniesienia wszystkich plików systemu do struktury, w której będzie je można zapisać w formacie gotowym do ostatecznego wdrożenia. Może się okazać, że równie czasochłonnym zadaniem będzie wdrożenie komponentów na serwerze i ich przygotowanie do prawidłowego funkcjonowania. Skracanie czasu poświęcanego na kompilację i wdrażanie systemu musi polegać na ograniczaniu ilości pracy potrzebnej do realizacji tych procesów. W ten sposób do- chodzimy do dwóch ważnych pojęć związanych z pracą systemów kompilujących: minimalnych kompilacji (ang. minimal builds) i minimalnych wdrożeń (ang. mini- mal deployments). Minimalne kompilacje Generowanie kodu źródłowego, kompilowanie tego kodu i upakowywanie plików bi- narnych w plikach JAR to zadania, które wymagają wielu zasobów. Jeśli istnieje możli- wość ograniczenia częstotliwości wykonywania któregoś z tych zadań, może to ozna- czać znaczne oszczędności czasowe. Tego rodzaju oszczędności w czasie pracy systemu kompilacji zwykle polegają na za- stępowaniu pełnego procesu kompilacji odpowiednimi zadaniami przyrostowymi, czyli kompilowaniem tylko tych komponentów, które uległy zmianie w ostatnim cyklu. Oznacza to, że jeśli zmieniono jakiś plik źródłowy, system kompilujący nie powinien ponownie generować całego systemu — powinien oferować mechanizmy wykrywa- nia zależności pomiędzy komponentami i obszarem aplikacji, na który dana zmiana rzeczywiście miała wpływ, aby na tej podstawie skompilować, upakować i wdrożyć tylko zmodyfikowane moduły. Rozdział 12. ♦ Optymalne kompilowanie systemów 327 Wdrożenia minimalne Kompilacje minimalne to tylko jeden z kroków zaradczych mających na celu skrócenie cykli kompilacji. Warto się również zastanowić, jak skompilowana aplikacja może osiągać stan, w którym będzie ją można uruchamiać i testować. W przypadku rozwiązań dla platformy J2EE naturalnym rozwiązaniem jest wdrażanie komponentów na serwerze aplikacji. Podejście polegające na minimalnych wdrożeniach sprowadza się do redukcji łącznej liczby kroków wykonywanych przez inżynierów oprogramowania podczas wdrażania zmienionej aplikacji na serwerze. Najgorszym przypadkiem jest oczywiście koniecz- ność zatrzymania serwera, ponownego wdrożenia całej aplikacji i przywrócenia pracy serwera. Opóźnienia związane z taką procedurą w wielu sytuacjach są nie do przyjęcia. Większość producentów serwerów aplikacji J2EE na szczęście zrozumiało, jak duże znaczenie ma szybkie i efektywne wdrażanie zmodyfikowanego oprogramowania, i w związku z tym ich systemy oferują funkcje wdrażania aplikacji „na gorąco”, w ruchu (ang. hot deployment). Z uwagi na swoje znaczenie dla efektywności procesu kompilacji praktyka wdrażania „na gorąco” wymaga dalszego wyjaśnienia. Czym jest wdrażanie „na gorąco”? Wdrażanie „na gorąco” jest rozwiązaniem stosowanym przez większość producentów serwerów aplikacji i sprowadzającym się do możliwości wdrażania zaktualizowanej aplikacji J2EE w docelowym, działającym środowisku bez konieczności wstrzymywa- nia pracy serwera lub samej aplikacji. W przypadku działających systemów technika wdrażania „na gorąco” w sposób oczywi- sty eliminuje problem dostępności oprogramowania. Inne oczekiwania w zakresie wdra- żania „na gorąco” mają programiści, którzy bardziej skłaniają się ku odmianie tej kon- cepcji nazywanej wdrażaniem automatycznym. Idea wdrażania automatycznego przewiduje, że serwer aplikacji stale „dopytuje się” o nowe pliki. W przypadku ich wykrycia, natychmiast wczytuje odnalezione zmiany i integruje nową wersję z bieżącą aplikacją. Automatyczne wdrażanie nie ma zastosowania w systemach pracujących w swoim docelowym środowisku, ponieważ konieczność nieustannego sprawdzania katalogów wdrożenia w poszukiwaniu nowych wersji plików stanowiłoby nadmierne obciążenie i — tym samym — obniżało wydajność tych systemów. W środowisku wytwarzania, w którym szczególny nacisk kładzie się efektywność pracy, tego typu funkcjonalność może znacznie odciążyć inżyniera oprogramowania, który nie będzie już musiał ręcznie wykonywać kroków związanych z wprowadzaniem nowych wersji budowanego oprogramowania do serwera aplikacji. Koncepcja automatycznego wdrażania nie jest częścią specyfikacji platformy J2EE, która wspomina tylko o wdrażaniu plików EAR, WAR, JAR i RAR. Okazuje się jed- nak, że serwery aplikacji (np. WebLogic firmy BEA) w tym zakresie wykraczają poza 328 Część IV ♦ Środowiska dynamiczne oficjalną specyfikację J2EE i oferują inżynierom oprogramowania obsługę znacznie bardziej wyrafinowanych mechanizmów wdrażania aplikacji niż tylko funkcji kopio- wania skompresowanych plików. Zalecane przez firmę BEA podejście do wdrażania jest całkowicie zgodne z ideą minimalnych wdrożeń. Serwer WebLogic obsługuje automatyczne wdrożenia pod warunkiem, że pracuje w try- bie wytwarzania. Aby uruchomić serwer w tym trybie, wystarczy ustawić wartość false dla właściwości systemowej -Dweblogic.ProductionModeEnabled. Aby sprawdzić, jakie mechanizmy w zakresie minimalnych wdrożeń i wdrożeń „na gorąco” oferuje Twój serwer aplikacji, musisz się dokładnie zapoznać z jego doku- mentacją. Do tej pory omówiliśmy kilka najważniejszych wymagań stawianych procesom kom- pilacji systemów informatycznych, zatem możemy przystąpić do tworzenia takiego pro- cesu. Aby było to możliwe, w pierwszej kolejności zapoznamy się z wygodnym narzę- dziem kompilującym. Wprowadzenie do narzędzia Ant Ant jest rozszerzalnym narzędziem opracowanym przez Apache Software Foundation. W programie Ant skrypty kompilacji tworzy się, stosując składnię zbliżoną do języka XML. Narzędzie jest oferowane z otwartym dostępem do kodu źródłowego i można je pobrać za darmo z witryny internetowej Apache’a (patrz http://ant.apache.org). Ant nie wymaga chyba wprowadzenia, ponieważ już od jakiegoś czasu jest de facto stan- dardowym narzędziem wykorzystywanym do kompilowania programów Javy. We wcze- śniejszych rozdziałach wielokrotnie wspominano, że takie narzędzia jak XDoclet, Middle- gen czy AndroMDA do swojego działania wymagają właśnie Anta. Narzędzie Middlegen omówiono w rozdziale 7., natomiast program AndroMDA opisano w rozdziale 8. Sukces programu Ant wynika przede wszystkim z jego bogatej funkcjonalności, która czyni z niego narzędzie idealnie pasujące do wytwarzania aplikacji Javy. Wykorzysty- wanie dokumentów XML (z jasną i czytelną składnią) w roli plików definiujących prze- bieg kompilacji powoduje, że programiści mogą bardzo szybko opanować techniki używania Anta. Trudności w tym zakresie były podstawowym problemem wcześniej- szych narzędzi Make, które bazowały na trudnej do nauki semantyce deklaratywnej. Co więcej, Ant został zaimplementowany w Javie i pracuje pod kontrolą wirtualnej maszyny Javy. Oznacza to, że Ant jest narzędziem niezależnym od platformy, prze- nośnym, co ma niemałe znaczenie dla programistów pracujących nad rozwiązaniami dla platformy J2EE. To także ogromna zaleta w porównaniu z wcześniejszymi narzę- dziami Make, które w procesie kompilowania oprogramowania korzystały z polecenia powłoki właściwej dla konkretnej platformy. Rozdział 12. ♦ Optymalne kompilowanie systemów 329 Ant stał się dojrzałym narzędziem kompilującym, który oferuje bardzo bogatą funkcjo- nalność w zakresie niemal wszystkich zadań kompilacji, jakie można sobie tylko wy- obrazić. Pliki kompilacji tego programu wywołują operacje kompilacji za pośrednic- twem tzw. zadań Anta (ang. Ant tasks). Ant oferuje zestaw kluczowych, wbudowanych zadań, za pomocą których można wyko- nywać wiele typowych operacji kompilacji — oto najważniejsze z nich: (cid:141) kompilacja kodu źródłowego Javy, (cid:141) definiowanie ścieżek do klas, (cid:141) generowanie dokumentacji JavaDoc, (cid:141) kopiowanie i usuwanie plików, (cid:141) zmiana uprawnień dostępu do plików, (cid:141) tworzenie plików JAR, (cid:141) uruchamianie aplikacji zewnętrznych, (cid:141) wywoływanie kroków kompilacji zdefiniowanych w pozostałych plikach kompilacji Anta, (cid:141) przetwarzanie formatów kompresji (w tym plików ZIP i TAR), (cid:141) wysyłanie wiadomości poczty elektronicznej, (cid:141) obsługa dostępu do repozytoriów oprogramowania kontroli wersji kodu źródłowego. W sytuacji, gdy wbudowane zadania Anta
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

J2EE. Podstawy programowania aplikacji korporacyjnych
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ą: