Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00099 007803 10476331 na godz. na dobę w sumie
J2EE. Wzorce projektowe - książka
J2EE. Wzorce projektowe - książka
Autor: , , Liczba stron: 368
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-988-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> j2ee - programowanie
Porównaj ceny (książka, ebook, audiobook).
W ciągu ostatnich kilku lat Java 2 Enterprise Edition stała się standardową platformą do budowy skomplikowanych aplikacji. Ponieważ jest ona rozbudowanym środowiskiem programistycznym, pozwalającym projektować i programować potężne aplikacje, nie jest łatwa w obsłudze. W książce, którą trzymasz w ręku, doświadczeni architekci Sun Java Center, organizacji konsultingowej, działającej w ramach Sun Java, dzielą się z czytelnikiem swoim doświadczeniem w projektowaniu aplikacji opartych na technologii J2EE.

Autorzy skupiają się na wzorcach projektowych, opartych na najważniejszych technologiach J2EE, takich jak Java Server Pages (JSP), serwlety, Enterprise JavaBeans (EJB) oraz Java Message Service (JMS). Omawiane są również inne technologie Javy, ważne dla prawidłowej implementacji wzorców, takie jak JDBC i JNDI. Katalog zawierający wzorce projektowe J2EE dokumentuje i prezentuje najlepsze sposoby wykorzystania tych technologii. To jednak nie wszystko. Książka omawia również:

O autorach
DEEPAK ALUR jest architektem Javy pracującym dla Sun Java Center. Od ponad 12 lat zajmuje się tworzeniem aplikacji komercyjnych. Jego zainteresowania koncentrują się na projektowaniu i implementacji aplikacji komercyjnych przy użyciu technologii zorientowanych obiektowo, wzorców, technologii Javy oraz J2EE.

JOHN CRUPI jest naczelnym architektem Sun Java Center. Od ponad 15 lat zajmuje się przetwarzaniem obiektów rozproszonych. Jest ekspertem w dziedzinie tworzenia elastycznych architektur w technologii J2EE. Prowadzi również kolumnę Architect's Corner w magazynie JavaReport.

DAN MALKS jest architektem Javy, pracujący dla Sun Java Center. Od ponad 14 lat zajmuje się tworzeniem aplikacji komercyjnych i technologiami zorientowanymi obiektowo. Jego publikacje znalazły się w wielu periodykach i książkach, dotyczących technologii Javy oraz wzorców projektowych.

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. Wzorce projektowe Autorzy: Deepak Alur, John Crupi, Dan Malks T³umaczenie: Maciel Gorywoda ISBN: 83-7197-988-6 Tytu³ orygina³u: Core J2EE Patterns Format: B5, stron: 360 W ci¹gu ostatnich kilku lat Java 2 Enterprise Edition sta³a siê standardow¹ platform¹ do budowy skomplikowanych aplikacji. Poniewa¿ jest ona rozbudowanym ġrodowiskiem programistycznym, pozwalaj¹cym projektowaæ i programowaæ potê¿ne aplikacje, nie jest ³atwa w obs³udze. W ksi¹¿ce, któr¹ trzymasz w rêku, doġwiadczeni architekci Sun Java Center, organizacji konsultingowej, dzia³aj¹cej w ramach Sun Java, dziel¹ siê z czytelnikiem swoim doġwiadczeniem w projektowaniu aplikacji opartych na technologii J2EE. Autorzy skupiaj¹ siê na wzorcach projektowych, opartych na najwa¿niejszych technologiach J2EE, takich jak Java Server Pages (JSP), serwlety, Enterprise JavaBeans (EJB) oraz Java Message Service (JMS). Omawiane s¹ równie¿ inne technologie Javy, wa¿ne dla prawid³owej implementacji wzorców, takie jak JDBC i JNDI. Katalog zawieraj¹cy wzorce projektowe J2EE dokumentuje i prezentuje najlepsze sposoby wykorzystania tych technologii. To jednak nie wszystko. Ksi¹¿ka omawia równie¿: • wiele strategii przydatnych przy projektowaniu warstw prezentacyjnej i biznesowej; • identyfikacjê b³êdnych technik znajdywanych w warstwach prezentacyjnej, biznesowej i integracyjnej oraz propozycje rozwi¹zañ wykorzystuj¹cych wzorce projektowe oraz sposoby przebudowy systemów; • metody przebudowy dla poszczególnych warstw aplikacji oraz techniki zastêpowania b³êdnych implementacji prawid³owymi; • przyk³adowy kod programów opartych na omawianych strategiach i wzorcach projektowych. Spis treści Podziękowania Przedsłowie I Przedsłowie II Wstęp Część I Wzorce i J2EE Rozdział 1. Wprowadzenie 9 11 12 13 19 21 Czym jest J2EE? ...................................................J...................................................J.............. 21 Czym są wzorce?...................................................J...................................................J............. 22 Historia ...................................................J...................................................J...................... 22 Definicja wzorca...................................................J...................................................J.........23 Kategorie wzorców ...................................................J...................................................J..... 24 Katalog wzorców J2EE ...................................................J...................................................J.....25 Nieprzerwana ewolucja ...................................................J................................................. 25 Jak korzystać z katalogu wzorców J2EE ...................................................J........................ 26 Korzyści wynikające z używania wzorców ...................................................J...................... 27 Wzorce, struktury oraz powtórne wykorzystanie...................................................J.................. 29 Podsumowanie ...................................................J...................................................J................ 29 Rozdział 2. Omówienie platformy J2EE 31 Krótko o historii...................................................J...................................................J............... 31 Serwery aplikacji — nowe pokolenie...................................................J............................. 32 Właściwości technologii Javy ...................................................J........................................ 33 Powstanie platformy J2EE...................................................J............................................. 34 Ocena wartości J2EE ...................................................J...................................................J. 34 Platforma J2EE ...................................................J...................................................J................ 35 Architektura J2EE...................................................J...................................................J....... 35 Java 2 Standard Edition...................................................J................................................ 36 Komponenty i pojemniki aplikacji J2EE ...................................................J......................... 37 Serwisy standardowe...................................................J...................................................J. 38 Role w platformie J2EE ...................................................J................................................. 39 Pliki opisów rozmieszczenia...................................................J.......................................... 40 Wzorce J2EE a platforma J2EE ...................................................J........................................... 41 Podsumowanie ...................................................J...................................................J................ 42 4 J2EE. Wzorce projektowe Część II Elementy projektów, niewłaściwe techniki oraz przebudowa systemu Rozdział 3. Elementy projektów oraz niewłaściwe techniki warstwy prezentacyjnej 43 45 Elementy projektowania warstwy prezentacyjnej...................................................J................. 45 Zarządzanie sesją ...................................................J...................................................J...... 45 Kontrola praw dostępu klienta ...................................................J...................................... 48 Walidacja ...................................................J...................................................J................... 52 Właściwości klas pomocniczych — integralność i konsekwencja..................................... 54 Niewłaściwe techniki zarządzania warstwą prezentacyjną...................................................J... 56 Kontrola kodu w widokach wielokrotnych...................................................J...................... 57 Udostępnianie struktur danych warstwy prezentacyjnej warstwie komercyjnej ................. 57 Udostępnianie struktur danych warstwy prezentacyjnej obiektom rodzimym.................... 58 Powielanie wysyłanych formularzy...................................................J................................. 58 Bezpośrednie udostępnianie ważnych zasobów...................................................J............ 59 Założenie, że jsp:setProperty będzie resetować własności komponentu ..................... 59 Tworzenie „grubych” sterowników...................................................J................................. 60 Rozdział 4. Elementy projektów oraz niewłaściwe techniki warstwy komercyjnej 61 Elementy projektowania warstwy komercyjnej ...................................................J.................... 61 Korzystanie z komponentów sesyjnych ...................................................J......................... 61 Korzystanie z komponentów jednostkowych ...................................................J................. 65 Pamięć podręczna dla odległych referencji i uchwytów EnterpriseBeans ......................... 67 Niewłaściwe techniki zarządzania warstwą komercyjną ...................................................J...... 67 Mapowanie modelu obiektu bezpośrednio na model jednostki ........................................ 67 Mapowanie modelu relacji bezpośrednio na model jednostki .......................................... 68 Mapowanie każdego rodzaju wykorzystania na komponent sesyjny ................................. 69 Obsługa wszystkich atrybutów komponentu poprzez metody zmiany lub dostępu............ 69 Umieszczenie serwisu aktualizującego w aplikacjach klienckich...................................... 69 Używanie jednostki w charakterze obiektu tylko do odczytu............................................. 70 Używanie jednostek w charakterze obiektów wyspecjalizowanych.................................... 71 Przechowywanie pełnej struktury obiektów zależnych od jednostki .................................. 72 Niepotrzebne ujawnianie wyjątków związanych z EJB ...................................................J.... 72 Używanie metod przeszukujących komponentów jednostkowych do zwracania dużych bloków danych ...................................................J.......................... 73 Klient sortujący dane dla komponentów komercyjnych ...................................................J. 73 Używanie EnterpriseBeans do obsługi transakcji czasochłonnych ................................... 74 Niezachowujące stanu komponenty odtwarzają stan konwersacji dla każdego wywołania...... 74 Rozdział 5. Sposoby przebudowy J2EE 77 Sposoby przebudowy warstwy prezentacyjnej ...................................................J..................... 77 Korzystanie ze sterownika ...................................................J............................................ 77 Korzystanie z synchronizatora...................................................J....................................... 79 Wyodrębnienie procedur rozproszonych ...................................................J........................ 83 Ukrycie danych warstwy prezentacyjnej przed warstwą komercyjną.................................. 89 Usuwanie konwersji z widoku...................................................J........................................ 92 Ukrywanie zasobów przed klientem ...................................................J.............................. 95 Sposoby przebudowy warstwy komercyjnej i integracyjnej ...................................................J.. 98 Zamknięcie komponentów jednostkowych w sesji...................................................J......... 98 Korzystanie z delegatów komercyjnych ...................................................J....................... 100 Łączenie komponentów sesyjnych ...................................................J.............................. 101 Ograniczanie komunikacji międzyjednostkowej ...................................................J........... 102 Przesunięcie procedur komercyjnych do sesji ...................................................J............. 104 Spis treści 5 Ogólne sposoby przebudowy ...................................................J............................................ 105 Separacja kodu dostępu do danych...................................................J............................ 105 Przebudowa architektury warstw ...................................................J................................. 107 Korzystanie z zestawu połączeń...................................................J.................................. 109 Część III Katalog wzorców J2EE Rozdział 6. Omówienie wzorców J2EE 111 113 Czym jest wzorzec?...................................................J...................................................J.. 113 Identyfikacja wzorca...................................................J...................................................J. 114 Podejście warstwowe ...................................................J...................................................J.... 115 Wzorce J2EE...................................................J...................................................J.................. 117 Wzorce warstwy prezentacyjnej ...................................................J................................... 117 Wzorce warstwy komercyjnej...................................................J....................................... 117 Wzorce warstwy integracyjnej...................................................J...................................... 117 Wprowadzenie do katalogu...................................................J............................................... 118 Terminologia ...................................................J...................................................J............ 118 Korzystanie z UML ...................................................J...................................................J... 121 Szablon wzorców...................................................J...................................................J...... 122 Relacje pomiędzy wzorcami J2EE ...................................................J..................................... 123 Relacje do innych znanych wzorców ...................................................J................................. 126 Mapa wzorców...................................................J...................................................J............... 126 Podsumowanie ...................................................J...................................................J.............. 130 Rozdział 7. Wzorce warstwy prezentacyjnej 131 Filtr przechwytujący...................................................J...................................................J........ 131 Kontekst ...................................................J...................................................J.................. 131 Problem ...................................................J...................................................J................... 131 Siły...................................................J...................................................J........................... 132 Rozwiązanie ...................................................J...................................................J............. 132 Konsekwencje...................................................J...................................................J.......... 145 Relacje z innymi wzorcami ...................................................J.......................................... 146 Sterownik frontalny...................................................J...................................................J........ 146 Kontekst ...................................................J...................................................J.................. 146 Problem ...................................................J...................................................J................... 146 Siły...................................................J...................................................J........................... 147 Rozwiązanie ...................................................J...................................................J............. 147 Konsekwencje...................................................J...................................................J.......... 156 Relacje z innymi wzorcami ...................................................J.......................................... 156 Pomocnik widoku ...................................................J...................................................J..........157 Kontekst ...................................................J...................................................J.................. 157 Problem ...................................................J...................................................J................... 157 Siły...................................................J...................................................J........................... 157 Rozwiązanie ...................................................J...................................................J............. 158 Konsekwencje...................................................J...................................................J.......... 169 Relacje z innymi wzorcami ...................................................J.......................................... 169 Widok złożony...................................................J...................................................J................ 170 Kontekst ...................................................J...................................................J.................. 170 Problem ...................................................J...................................................J................... 170 Siły...................................................J...................................................J........................... 170 Rozwiązanie ...................................................J...................................................J............. 170 6 J2EE. Wzorce projektowe Konsekwencje...................................................J...................................................J.......... 177 Przykładowy kod...................................................J...................................................J....... 178 Relacje z innymi wzorcami ...................................................J.......................................... 179 Struktura usługa-pracownik ...................................................J.............................................. 180 Kontekst ...................................................J...................................................J.................. 180 Problem ...................................................J...................................................J................... 180 Siły...................................................J...................................................J........................... 180 Rozwiązanie ...................................................J...................................................J............. 181 Konsekwencje...................................................J...................................................J.......... 185 Przykładowy kod...................................................J...................................................J....... 186 Relacje z innymi wzorcami ...................................................J.......................................... 191 Widok przekaźnika...................................................J...................................................J......... 191 Kontekst ...................................................J...................................................J.................. 191 Problem ...................................................J...................................................J................... 192 Siły...................................................J...................................................J........................... 192 Rozwiązanie ...................................................J...................................................J............. 192 Konsekwencje...................................................J...................................................J.......... 197 Przykładowy kod...................................................J...................................................J....... 198 Relacje z innymi wzorcami ...................................................J.......................................... 202 Rozdział 8. Wzorce warstwy komercyjnej 203 Delegat komercyjny ...................................................J...................................................J.......203 Kontekst ...................................................J...................................................J.................. 203 Problem ...................................................J...................................................J................... 203 Siły...................................................J...................................................J........................... 204 Rozwiązanie ...................................................J...................................................J............. 204 Konsekwencje...................................................J...................................................J.......... 208 Przykładowy kod...................................................J...................................................J....... 209 Relacje z innymi wzorcami ...................................................J.......................................... 213 Obiekt wartości ...................................................J...................................................J............. 213 Kontekst ...................................................J...................................................J.................. 213 Problem ...................................................J...................................................J................... 213 Siły...................................................J...................................................J........................... 214 Rozwiązanie ...................................................J...................................................J............. 214 Konsekwencje...................................................J...................................................J.......... 223 Przykładowy kod...................................................J...................................................J....... 224 Relacje z innymi wzorcami ...................................................J.......................................... 235 Fasada sesji ...................................................J...................................................J.................. 235 Kontekst ...................................................J...................................................J.................. 235 Problem ...................................................J...................................................J................... 235 Siły...................................................J...................................................J........................... 237 Rozwiązanie ...................................................J...................................................J............. 237 Konsekwencje...................................................J...................................................J.......... 241 Przykładowy kod...................................................J...................................................J....... 243 Relacje z innymi wzorcami ...................................................J.......................................... 249 Jednostka złożona...................................................J...................................................J......... 250 Kontekst ...................................................J...................................................J.................. 250 Problem ...................................................J...................................................J................... 250 Siły...................................................J...................................................J........................... 252 Rozwiązanie ...................................................J...................................................J............. 253 Konsekwencje...................................................J...................................................J.......... 259 Spis treści 7 Przykładowy kod...................................................J...................................................J....... 260 Relacje z innymi wzorcami ...................................................J.......................................... 269 Asembler obiektów wartości...................................................J............................................. 269 Kontekst ...................................................J...................................................J.................. 269 Problem ...................................................J...................................................J................... 269 Siły...................................................J...................................................J........................... 272 Rozwiązanie ...................................................J...................................................J............. 273 Konsekwencje...................................................J...................................................J.......... 276 Przykładowy kod...................................................J...................................................J....... 277 Relacje z innymi wzorcami ...................................................J.......................................... 281 Uchwyt listy wartości ...................................................J...................................................J..... 281 Kontekst ...................................................J...................................................J.................. 281 Problem ...................................................J...................................................J................... 282 Siły...................................................J...................................................J........................... 282 Rozwiązanie ...................................................J...................................................J............. 283 Konsekwencje...................................................J...................................................J.......... 286 Przykładowy kod...................................................J...................................................J....... 287 Relacje z innymi wzorcami ...................................................J.......................................... 292 Lokalizator usług ...................................................J...................................................J........... 292 Kontekst ...................................................J...................................................J.................. 292 Problem ...................................................J...................................................J................... 293 Siły...................................................J...................................................J........................... 294 Rozwiązanie ...................................................J...................................................J............. 295 Konsekwencje...................................................J...................................................J.......... 302 Przykładowy kod...................................................J...................................................J....... 302 Relacje z innymi wzorcami ...................................................J.......................................... 306 Rozdział 9. Wzorce warstwy integracyjnej 307 Obiekt dostępu do danych...................................................J................................................ 307 Kontekst ...................................................J...................................................J.................. 307 Problem ...................................................J...................................................J................... 307 Siły...................................................J...................................................J........................... 308 Rozwiązanie ...................................................J...................................................J............. 308 Konsekwencje...................................................J...................................................J.......... 312 Przykładowy kod...................................................J...................................................J....... 314 Relacje z innymi wzorcami ...................................................J.......................................... 320 Aktywator usług ...................................................J...................................................J............. 320 Kontekst ...................................................J...................................................J.................. 320 Problem ...................................................J...................................................J................... 320 Siły...................................................J...................................................J........................... 321 Rozwiązanie ...................................................J...................................................J............. 321 Konsekwencje...................................................J...................................................J.......... 324 Przykładowy kod...................................................J...................................................J....... 325 Relacje z innymi wzorcami ...................................................J.......................................... 330 Dodatki Epilog Bibliografia Skorowidz 331 333 345 349 5 Sposoby przebudowy J2EE Sposoby przebudowy warstwy prezentacyjnej W tym podrozdziale zajmiemy się sposobami przebudowy warstwy prezentacyjnej. Korzystanie ze sterownika Procedury sterowania są rozproszone po całym kodzie aplikacji — zazwyczaj powielane są w wielu widokach stron serwerowych Javy (Java Server Pages, JSP). Procedury sterowania należy wyodrębnić w przynajmniej jednej klasie sterowników. Klasy te odgrywają główną rolę w procesie obsługi żądań klientów. Rysunek 5.1. Korzystanie ze sterownika 78 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu Motywacja Powielany na różnych stronach JSP kod sterowania musi być przez każdą z nich utrzymy- wany. Wyodrębnienie takiego kodu w jednej klasie lub w większej ilości klas sterownika zwiększa przejrzystość oraz możliwości wielokrotnego wykorzystania aplikacji, a także ułatwia jej utrzymanie. Mechanika n Klasę sterownika należy utworzyć za pomocą wzorca klasy wydobycia (Extract Class [Fowler]) oraz wzorca sterownika frontalnego. Pozwala to na przeniesienie procedur sterowania z poszczególnych stron JSP do powstałego w ten sposób sterownika. n Przejdź do akapitu „Sterownik frontalny” (strona 146). n Należy pamiętać, że klasa sterownika stanowi punkt wyjścia w procesie sterowania obsługą żądań. Strukturę kodu aplikacji musi cechować modularność oraz możliwość wielokrotnego wykorzystania. Czasami zamiast tworzenia pojedynczego sterownika konieczne jest utworzenie obiektów pomocniczych i rozmieszczenie w nich kodu sterowania. Przejdź do akapitu „Tworzenie „grubych” sterowników” (strona 60). n Przy korzystaniu ze wzorca polecenia (Command [GoF]) kod sterowania można również wyodrębnić w obiektach poleceń skoordynowanych ze sterownikiem. n Przejdź do akapitów „Sterownik frontalny” (strona 146). Przykład Załóżmy, że wiele stron JSP przykładowej aplikacji ma strukturę taką, jak w listingu 5.1. Listing 5.1. Korzystanie ze sterownika — struktura JSP *6/. $1 ; EQPVTQNITCPVACEEGUU    $1 ; *6/. W wykropkowanej części listingu znajduje się właściwy kod każdej strony JSP, którego tu nie pokazano, a który jest różny w poszczególnych stronach JSP. Nie zmienia się jednak kom- ponent pomocniczy, zaimplementowany na początku kodu każdej strony jako dodatkowo zdefiniowany znacznik. Komponent ten odpowiada za kontrolę dostępu do strony. Jest to kontrola typu „wszystko albo nic”, co oznacza, że klient może uzyskać całkowity dostęp do strony albo nie uzyskać go w ogóle. Rozdział 5. n Sposoby przebudowy J2EE 79 Aby zmienić strukturę poprzez wprowadzenie sterownika, zgodnie z opisem zamieszczonym w poprzedniej sekcji, należy usunąć ze stron JSP znacznik EQPVTQNITCPVACEEGUU , poka- zany w listingu 5.1. Funkcję tego znacznika, który do tej pory zawarty był we wszystkich stronach JSP, będzie pełnił scentralizowany sterownik, obsługujący kontrolę dostępu. Listing 5.2 ukazuje fragment kodu sterownika, zaimplementowanego jako serwlet. Listing 5.2. Korzystanie ze sterownika — struktura sterownika KH ITCPV#EEGUU ] FKURCVEJ6Q0GZV8KGY  _ GNUG ] FKURCVEJ6Q#EEGUU GPKGF8KGY  _ Oczywiście w pewnych sytuacjach komponenty pomocnicze dobrze spełniają rolę kodu stero- wania. Jeżeli na przykład tylko ograniczona liczba stron JSP wymaga tego rodzaju kontroli dostępu, to rozsądnym rozwiązaniem jest użycie komponentu pomocniczego w postaci dodat- kowo zdefiniowanego znacznika na tych wybranych stronach. Użycie dodatkowo definio- wanych znaczników w poszczególnych stronach JSP jest również uzasadnione, gdy chcemy kontrolować dostęp do określonych podwidoków widoku złożonego (przejdź do akapitu „Widok złożony” w rozdziale 7.). Nawet jeżeli korzystamy już ze sterownika, warto rozważyć zastosowanie omawianego tu rozwiązania scentralizowanego, ponieważ liczba stron wymagających takiego zabezpiecze- nia może się z czasem zwiększyć. Jeżeli więc sterownik został już utworzony, należy wy- odrębnić z widoków kod sterowania i dodać go do istniejącego sterownika. Oznacza to, że konieczne będzie przeniesienie metod (za pomocą wzorca metody przesunięcia — Move Method [Fowler]), a nie wyodrębnienie nowej klasy. Korzystanie z synchronizatora Żądania dostępu do zasobów, wysyłane przez klientów, wymagają monitorowania i kontroli. Pewnym problemem może być powtarzalność takich żądań. Klienci mogą też żądać dostępu do pewnych widoków w różnej kolejności, powracając do poprzednio odwiedzanych, zazna- czonych stron. Skorzystanie z synchronizatora (ang. synchronizer token) umożliwia kontrolę przepływu żądań oraz dostępu klientów do określonych zasobów. Motywacja Istnieje szereg sytuacji, które wymagają kontrolowania przychodzących żądań. Są to najczę- ściej żądania wysyłane powtórnie przez klienta. Powtórzenie żądania ma miejsce na przykład wtedy, gdy użytkownik kliknie w przeglądarce przycisk Wstecz lub Zatrzymaj i ponownie prześle dany formularz. 80 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu Rysunek 5.2. Korzystanie z synchronizatora Chociaż chodzi tu głównie o sterowanie kolejnością i przepływem żądań, należy również wspomnieć o zagadnieniach kontroli dostępu opartej na zezwoleniach. Użycie kontroli dostępu opartej na zezwoleniach omówiono w podrozdziale „Ukrywanie zasobów przed klientem”. Mechanika n Należy utworzyć jedną lub więcej klas pomocniczych, obsługujących generowanie i porównywanie jednorazowych, unikatowych synchronizatorów. n Rozwiązanie to można również dołączyć do istniejących komponentów sterowania. n Za pomocą takich obiektów pomocniczych komponent zarządzający żądaniami (zazwyczaj jest to sterownik, ale może to również być strona JSP) obsługuje tymczasowe przechowywanie aktualnego synchronizatora dla każdego żądania przesyłanego przez klienta. n Kopię synchronizatora przechowuje dla każdego użytkownika zarówno serwer, jak też przeglądarka klienta. Przeglądarka przechowuje synchronizator zazwyczaj w postaci ukrytego pola, a serwer w sesji użytkownika. Generowanie, zachowywanie i porównywanie synchronizatorów Zanim odebrane żądanie zostanie przetworzone, sprawdzana jest zgodność synchronizatora. Po prze- tworzeniu żądania generowany i zapisywany jest nowy synchronizator. Dopiero wtedy odpowiedź zostaje przygotowana i odesłana do klienta. Dalsze informacje na ten temat zawiera podrozdział „Korzystanie z synchronizatora” oraz rysunek 5.3. Rysunek 5.3. Cykl „życia” synchronizatora Rozdział 5. n Sposoby przebudowy J2EE 81 n Dołącz kod sprawdzający, czy synchronizator, przesyłany wraz z żądaniem klienta, odpowiada synchronizatorowi sesji użytkownika. n Wartość synchronizatora przesyłanego przez klienta w bieżącym żądaniu powinna być taka sama, jak wartość synchronizatora, który serwer przesłał do klienta w ostatniej odpowiedzi. Zgodność tych dwóch wartości daje gwarancję, że żądanie nie zostało powtórnie przesłane, podczas gdy brak zgodności może oznaczać, że miało miejsce powtórzenie żądania. n Jak już wspomniano, możliwe są również inne przyczyny braku zgodności tych wartości — użytkownik mógł na przykład udać się bezpośrednio na odwiedzoną wcześniej, zaznaczoną stronę. Najczęstszym jednak powodem pozostaje powtórne przesłanie żądania. Klasa sterownika zazwyczaj obsługuje generowanie oraz porównywanie synchronizatorów. Jeżeli aplikacja nie posiada sterownika, to warto rozważyć jego utworzenie. n Zobacz „Korzystanie ze sterownika” na stronie 77. n W przypadku braku sterownika centralnie obsługującego generowanie i porównywanie synchronizatorów konieczne jest zapewnienie takiej obsługi z poziomu każdej strony JSP. n Zazwyczaj strony JSP wykorzystują w tym celu komponent pomocniczy, zaimplementowany w postaci obiektu JavaBean lub dodatkowo zdefiniowanego znacznika (zobacz „Pomocnik widoku” — strona 157), który zapewnia odpowiednie zarządzanie synchronizatorami. Fragmenty kodu źródłowego, przedstawione w sekcji „Korzystanie z synchronizatora”, zostały użyte zgodnie z warunkami licencji Apache Software License, Version 1.1. Przykład W szkielecie warstwy prezentacji Struts zastosowano kilka wzorców i sposobów przebu- dowy J2EE, między innymi omawiany tu rodzaj kontroli przepływu żądań. W poniższym przykładzie wykorzystamy fragmenty kodu źródłowego tego szkieletu. W szkielecie Struts nie jest tworzona oddzielna klasa, obsługująca generowanie i porówny- wanie synchronizatorów — funkcjonalność ta jest dodana do utworzonej wcześniej klasy, która stanowi część mechanizmu sterowania szkieletu. Jest to klasa o nazwie #EVKQP („działanie”), będąca wspólną klasą nadrzędną wszystkich działań. Działania są obiektami typu QOOCPF („polecenie”), stanowiącymi rozszerzenie funkcjonalności sterownika. Jest to aplikacja zgodna ze wzorcem sterownika frontalnego oraz strategią sterownika i polecenia. Listing 5.3 pokazuje, w jaki sposób metoda UCXG6QMGP , zdefiniowana w klasie #EVKQP, generuje i zachowuje wartości synchronizatorów. Listing 5.3. Generowanie i zachowywanie synchronizatorów   CRKUCPKGU[PEJTQPKCVQTCPQYGLVTCPUCMELK YDKGľæEGLUGULKWľ[VMQYPKMC9TCKG RQVTGD[VYQTQPCLGUVPQYCUGULC 82 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu  RCTCOTGSWGUV2TGVYCTCPGľæFCPKGUGTYNGVW  RTQVGEVGFXQKFUCXG6QMGP *VVR5GTXNGV4GSWGUVTGSWGUV ] *VVR5GUUKQPUGUUKQPTGSWGUVIGV5GUUKQP  5VTKPIVQMGPIGPGTCVG6QMGP TGSWGUV  KH VQMGPPWNN UGUUKQPUGV#VVTKDWVG 64#05# 6+10A61- 0A- ;VQMGP  _ Copyright © 1999 The Apache Software Foundation. Wszelkie prawa zastrzeżone. Metoda ta generuje unikatowy synchronizator w oparciu o ID sesji i bieżący czas, a następnie zapisuje uzyskaną w ten sposób wartość w sesji użytkownika. Jeszcze przed wygenerowaniem kodu HTML dla klienta przesyłającego żądanie, którego powtórzenia chcemy uniknąć (zazwyczaj jest to formularz odsyłany do serwera), w opisany wcześniej sposób ustawiana jest wartość synchronizatora. Wartość ta zostaje ustawiona po- przez wywołanie metody UCXG6QMGP : UCXG6QMGP TGSWGUV  Dodatkowo strona JSP, generująca wyświetlany kod HTML, zawiera również kod, który — przy wykorzystaniu klasy pomocniczej — generuje ukryte pole, zawierające wartość synchronizatora. Dzięki temu strona odsyłana do klienta (zazwyczaj z formularzem odsyła- nym do serwera) zawiera takie ukryte pole: KPRWVV[RGJKFFGP PCOGQTICRCEJGUVTWVUVCINKDJVON61- 0 XCNWGFEGCFGEC Atrybut XCNWG tego ukrytego pola zawiera wartość synchronizatora, wygenerowanego przez metodę UCXG6QMGP . Gdy klient przesyła stronę zawierającą to ukryte pole, sterownik — poprzez obiekt QOOCPF (będący podklasą klasy #EVKQP) — porównuje wartość synchronizatora w sesji użytkownika z wartością parametru TGSWGUV, przesyłanego wraz z ukrytym polem strony. Do porównania tych wartości obiekt QOOCPF wykorzystuje metodę pokazaną w listingu 5.4, a zaczerpniętą z jego klasy nadrzędnej (również w tym przypadku jest to klasa #EVKQP). Listing 5.4. Sprawdź poprawność synchronizatora   YTCECYCTVQħèEQFG VTWGEQFG LGľGNKYDKGľæEGLUGULKWľ[VMQYP;KMCRTGEJQY[YCP[ LGUVU[PEJTQPKCVQTVTCPUCMELKMVÎTGIQYCTVQħèLGUVIQFPC;YCTVQħEKæRTGMCCPæ LCMQRCTCOGVTTGSWGUV  YTCECYCTVQħèEQFG HCNUGEQFG YRT[RCFMWCKUVPKGPKCMVÎTG;IQħRQPKľU[EJ YCTWPMÎY WN NK ľæFCPKGPKGLGUVRT[RKUCPGFQľCFPGLUGULKNK NK YUGULKPKGCRKUCPQľCFPGIQU[PEJTQPKCVQTCNK NK PKGKUVPKGLGRCTCOGVTTGSWGUVCYKGTCLæE[YCTVQħèU[PEJT;QPKCVQTCNK NK YCTVQħèCđæEQPGIQU[PEJTQPKCVQTCVTCPUCMELKTÎľPKUKú;QFYCTVQħEK U[PEJTQPKCVQTCVTCPUCMELKRTGEJQY[YCPGLYUGULKWľ[VMQYPKMC;NK Rozdział 5. n Sposoby przebudowy J2EE 83 WN  RCTCOTGSWGUV2TGVYCTCPGľæFCPKGUGTYNGVW  RTQVGEVGFDQQNGCPKU6QMGP8CNKF *VVR5GTXNGV4GSWGUVTGSWGUV ;] 2QDTCPKGU[PEJTQPKCVQTCVTCPUCMELKCRKUCPGIQYDKGľæE;GLUGULK *VVR5GUUKQPUGUUKQPTGSWGUVIGV5GUUKQP HCNUG  KH UGUUKQPPWNN TGVWTP HCNUG  5VTKPIUCXGF 5VTKPI UGUUKQPIGV#VVTKDWVG 64#05# 6+10A61- 0A- ;  KH UCXGFPWNN TGVWTP HCNUG  2QDTCPKGU[PEJTQPKCVQTCVTCPUCMELKCđæEQPGIQYDKGľæE[O;ľæFCPKW 5VTKPIVQMGP 5VTKPI TGSWGUVIGV2CTCOGVGT QPVCPVU61- 0A- ;  KH VQMGPPWNN TGVWTP HCNUG  5RTCYFGPKGIQFPQħEKQDWYCTVQħEK TGVWTP UCXGFGSWCNU VQMGP  _ Copyright © 1999 The Apache Software Foundation. Wszelkie prawa zastrzeżone. Jeżeli porównywane wartości są identyczne, to mamy pewność, że dane żądanie nie zostało przesłane powtórnie. Jeżeli natomiast wartości synchronizatorów są różne, pozwala to podjąć odpowiednie czynności obsługi powtórzonych żądań. Wyodrębnienie procedur rozproszonych Procedury komercyjne oraz kod prezentacji (formatowania) są ze sobą przemieszane w po- szczególnych widokach stron JSP. Procedury komercyjne należy wyodrębnić w jednej lub większej ilości klas pomocniczych, z których będzie korzystać strona JSP lub sterownik. Rysunek 5.4 ukazuje wyodrębnienie procedur komercyjnych z widoku do klas pomocniczych. Rysunek 5.4. Wyodrębnienie procedur rozproszonych: przebudowa wstecz 84 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu Rysunek 5.5 ukazuje wyodrębnienie logiki komercyjnej z widoku do sterownika, obiektu QOOCPForaz klas pomocniczych. Rysunek 5.5. Wyodrębnienie procedur rozproszonych: przebudowa naprzód Motywacja Celem jest zwiększenie przejrzystości i spójności tworzonych aplikacji przy jednoczesnym zmniejszeniu ilości powielanych fragmentów kodu, co zwiększy modularność i możliwość wielokrotnego wykorzystania kodu aplikacji. Przejrzysta struktura elementów aplikacji po- zwala również na wyraźny podział pracy pomiędzy twórcami kodu formatowania aplikacji WWW a programistami, zajmującymi się procedurami komercyjnymi. Mechanika n W oparciu o wzorce klasy wydobycia (Extract Class [Fowler]) oraz pomocnika widoku należy utworzyć nowe klasy pomocnicze, przesuwając do nich procedury komercyjne ze stron JSP. n Klasy te należy udostępnić z poziomu stron JSP. n Przejdź do akapitu „Pomocnik widoku” (strona 157). n Punktem wyjściowym w procesie obsługi żądania może być widok, jak to pokazano na diagramie przebudowy wstecz na rysunku 5.4. Przejdź do akapitu. „Widok przekaźnika” (strona 191). n Warto rozważyć skorzystanie ze sterownika, jeżeli aplikacja go nie posiada. n Przejdź do akapitu „Korzystanie ze sterownika” na stronie 77. n Jak to przedstawiono na diagramie przebudowy naprzód (rysunek 5.5), sterownik może korzystać z obiektu pomocniczego QOOCPF. n Punktem wyjściowym w procesie obsługi żądania klientów może być sterownik, jak to pokazuje diagram przebudowy naprzód. Przejdź do akapitu „Struktura usługa-pracownik” (strona 180). Rozdział 5. n Sposoby przebudowy J2EE 85 Przykład Rozważmy kod, przedstawiony w widoku w listingu 5.5. Jest to strona JSP, zawierająca fragmenty skryptletu oraz kodu procedur komercyjnych. Listing 5.5. Strona JSP zawierająca kod skryptletu JVON JGCF VKVNG .KUVCRTCEQYPKMÎYVKVNG JGCF DQF[ 9[ħYKGVNGPKGPCYKUMYU[UVMKEJRTCEQYPKMÎYFCPGIQFKCđWMVÎT[EJC;TQDMKPKG RTGMTCECLæRQFCPGIQNKOKVW  1MTGħNGPKGPCY[FKCđWMVÎTGIQRTCEQYPKE[OCLæ QUVCèY[ħYKGVNGPK 5VTKPIFGRVKF5VTTGSWGUVIGV2CTCOGVGT  QPUVCPVU4 3A 26+  1MTGħNGPKGNKOKVWCTQDMÎY 5VTKPIUCNCT[5VTTGSWGUVIGV2CTCOGVGT  QPUVCPVU4 3A5#.#4;  9GT[HKMCELCRCTCOGVTÎY ,GľGNKY[UQMQħèCTQDMÎYNWDFKCđPKGQUVCđ[QMTGħNQPG Y[ħYKGVNCPCLGUVUVTQPCKPHQTOCELæQDđúFKG KH  FGRVKF5VTPWNN ^^ UCNCT[5VTPWNN  ] TGSWGUVUGV#VVTKDWVG QPUVCPVU#664A/ 55#)  $TCMY[OCICP[EJRCTCOGVTÎYY[UWMKYCPKC  KCđK CTQDMK   TGSWGUVIGV4GSWGUV KURCVEJGT GTTQTLUR  HQTYCTF TGSWGUVTGURQPUG  _ -QPYGTULCRCTCOGVTÎY RQDTCP[EJLCMQđCēEWEJ[PCMÎY PCV[R[PWOGT[EPG KPVFGRVKF HNQCVUCNCT[ VT[ ] FGRVKF+PVGIGTRCTUG+PV FGRVKF5VT  UCNCT[(NQCVRCTUG(NQCV UCNCT[5VT  _ ECVEJ 0WODGT(QTOCV ZEGRVKQPG ] TGSWGUVUGV#VVTKDWVG QPUVCPVU#664A/ 55#)  0KGYđCħEKYGYCTVQħEKY[UWMKYCPKC  FGRCTVOGPVKFCPFUCNCT[   TGSWGUVIGV4GSWGUV KURCVEJGT GTTQTLUR  HQTYCTF TGSWGUVTGURQPUG  _ 86 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu 5RTCYFGPKGRQRTCYPQħEKCMTGUWRCTCOGVTÎY KH UCNCT[ ] TGSWGUVUGV#VVTKDWVG QPUVCPVU#664A/ 55#)  0KGYđCħEKYGYCTVQħEKY[UWMKYCPKC  FGRCTVOGPVKFCPFUCNCT[   TGSWGUVIGV4GSWGUV KURCVEJGT GTTQTLUR  HQTYCTF TGSWGUVTGURQPUG  _  J EGPVGT .KUVCRTCEQYPKMÎYYFKCNG FGRVKF CTCDKCLæE[EJFQUCNCT[ J  +VGTCVQTGORNQ[GGUPGY ORNQ[GG GNGICVG  IGV ORNQ[GGU FGRVKF   VCDNGDQTFGT VT VJ +OKúVJ VJ 0CYKUMQVJ VJ 5VCPQYKUMQVJ VJ 0WOGTKFGPV[HKMCE[LP[VJ VJ 1FNKEGPKCQFRQFCVMWVJ VJ 7YCIKPCVGOCVY[FCLPQħEKVJ VJ 4QEPGCTQDMKVJ VT  YJKNG GORNQ[GGUJCU0GZV  ]  ORNQ[GG81GORNQ[GG ORNQ[GG81 GORNQ[GGUPGZV  NKUVCRTCEQYPKMÎYQUVCPKGY[ħYKGVNQPC LGľGNKQMTGħNQPQRQRTCYPGMT[VGTKCY[UWMKYCPKC KH GORNQ[GGIGV;GCTN[5CNCT[ UCNCT[ ]  VT VF GORNQ[GGIGV(KTUV0COG  VF VF GORNQ[GGIGV.CUV0COG  VF VF GORNQ[GGIGV GUKIPCVKQP  VF VF GORNQ[GGIGV+F  VF VF GORNQ[GGIGV0Q1H GFWEVKDNGU  VF VF GORNQ[GGIGV2GTHQTOCPEG4GOCTMU  VF VF GORNQ[GGIGV;GCTN[5CNCT[  VF VT  _ _  VCDNG Rozdział 5. n Sposoby przebudowy J2EE 87  KPENWFGHKNGLURVTCEGLUR 2 $ 2TQEGFWT[MQOGTE[LPGQTCMQFHQTOCVQYCPKC YCTUVYCRTGG;PVCE[LPC Uæ RTGOKGUCPGYV[OYKFQMW,52$ DQF[ JVON Przedstawiony powyżej kod JSP generuje tabelę HTML, zawierającą listę pracowników o określonych zarobkach. Zawarto tu zarówno procedury komercyjne, jak też kod forma- towania, co zilustrowano na rysunku 5.6. Rysunek 5.6. Widok, w którym przemieszano logikę komercyjną z kodem formatowania W listingu 5.6 pokazano, w jaki sposób w oparciu o wzorzec pomocnika widoku można zmienić strukturę tak, aby wyodrębnić kod skryptletu z widoku JSP. Listing 5.6. Strona JSP po wyodrębnieniu kodu skryptletu  VCINKDWTK9 $+0(EQTGRCVVGTPUVCINKDTCT[VNF RTGHKZEQTGRCVVGTPU JVON JGCF VKVNG .KUVCRTCEQYPKMÎYVKVNG JGCF DQF[ EQTGRCVVGTPUGORNQ[GG#FCRVGT J EGPVGT .KUVCRTCEQYPKMÎYFKCđW EQTGRCVVGTPUFGRCTVOGPVCVVTKDWVGKF RT[MđCFWľ[EKCQDKGMVWRQOQEPKEGIQYFQFCVMQYQFGHKPKQYCP[OPCE;PKMWJ VCDNGDQTFGT VT VJ +OKúVJ VJ 0CYKUMQVJ VJ 5VCPQYKUMQVJ VJ 0WOGTKFGPV[HKMCE[LP[RTCEQYPKMCVJ VJ 1FNKEGPKCQFRQFCVMWVJ VJ 7YCIKPCVGOCVY[FCLPQħEKVJ VJ 4QEPGCTQDMKVJ VT EQTGRCVVGTPUGORNQ[GGNKUVKFGORNQ[GGNKUVAMG[ VT VF EQTGRCVVGTPUGORNQ[GG CVVTKDWVG(KTUV0COG VF VF EQTGRCVVGTPUGORNQ[GG CVVTKDWVG.CUV0COG VF VF EQTGRCVVGTPUGORNQ[GG CVVTKDWVG GUKIPCVKQP VF VF EQTGRCVVGTPUGORNQ[GG CVVTKDWVG+F VF 88 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu VF EQTGRCVVGTPUGORNQ[GG CVVTKDWVG0Q1H GFWEVKDNGU VF VF EQTGRCVVGTPUGORNQ[GG CVVTKDWVG2GTHQTOCPEG4GOCTMU VF VF EQTGRCVVGTPUGORNQ[GG CVVTKDWVG;GCTN[5CNCT[ VF VF VT EQTGRCVVGTPUGORNQ[GGNKUV VCDNG DQF[ JVON Poza tym zdefiniowano dwa obiekty pomocnicze, zaimplementowane w dodatkowo zdefi- niowanych znacznikach, co pozwoliło na wyodrębnienie procedur komercyjnych oraz for- matowania poprzez oparcie modelu danych na kolumnach i wierszach tabeli HTML. Dwa obiekty pomocnicze, o których mowa, to znaczniki EQTGRCVVGTPUGORNQ[GGNKUV oraz EQTGRCVVGTPUGORNQ[GG . Rysunek 5.7 ukazuje transformację projektu: od struktury pokazanej po lewej stronie do struktury pokazanej po prawej stronie. Rysunek 5.7. Wyodrębnienie logiki komercyjnej w klasach pomocniczych Procedury komercyjne zostały wyodrębnione w klasach pomocniczych, dzięki czemu nie znajdują się już bezpośrednio na stronie JSP. Klasy te pełnią szereg funkcji, takich jak po- bieranie określonej zawartości, kontrolowanie dostępu, oraz wyświetlanie stanu modelu dla użytkownika. W przypadku ostatniej z wymienionych funkcji klasa pomocnicza hermetyzuje część logiki prezentacji, np. formatowanie zbioru wyniku zapytania w postaci tabeli HTML (zobacz także „Usuwanie konwersji z widoku”). Takie rozwiązania pozwalają spełnić po- stawiony wcześniej cel wyodrębnienia jak największej części logiki programowania z widoku. Dzięki temu z poziomu JSP możliwe jest, poprzez użycie klas pomocniczych, uzyskanie tabeli z określonymi danymi w miejsce kodu skryptletu generującego taką tabelę, zamieszczanego w kodzie JSP. Komponenty pomocnicze można implementować w postaci obiektów JavaBean lub też jako dodatkowo definiowane znaczniki (przejdź do akapitu „Pomocnik widoku” w rozdziale 7.). Komponenty pomocnicze JavaBean sprawdzają się najlepiej przy wyodrębnianiu logiki po- bierania zadanej zawartości oraz przechowywania wyników zapytań. Natomiast dodatkowo zdefiniowanych znaczników należy używać do omówionej powyżej konwersji modelu przy wyświetlaniu wyniku, czyli na przykład przy tworzeniu tabeli z zwróconego zbioru wyniku. Obie te opcje mają ze sobą wiele wspólnego, więc wybór techniki implementacji komponen- tów pomocniczych będzie zależał od doświadczenia programisty i względów praktycznych. Rysunek 5.8 ilustruje drugi punkt podrozdziału „Mechanika”, czyli przekazywanie zadań do klas pomocniczych z poziomu JSP. Rozdział 5. n Sposoby przebudowy J2EE 89 Rysunek 5.8. Przekazywanie zadań do klas pomocniczych Z poziomu widoku JSP wywoływane są klasy pomocnicze, które odpowiadają za przetwa- rzanie i generowanie widoku. Zazwyczaj przed stroną JSP używany jest sterownik jako punkt wyjściowy w procesie obsługi żądań klientów (przejdź do akapitów „Sterownik frontalny” w rozdziale 7. oraz „Korzystanie ze sterownika”). Sterownik udostępnia widok, ale zanim do tego dojdzie, może również przekazać zadania do komponentów pomocniczych (przejdź do akapitu „Struktura usługa-pracownik” w rozdziale 7.). Zmiany w strukturze po zastoso- waniu sterownika przedstawiono na rysunku 5.9. Rysunek 5.9. Korzystanie ze sterownika Ukrycie danych warstwy prezentacyjnej przed warstwą komercyjną Obsługa żądań oraz (lub) związane z obsługą protokołu struktury danych są udostępniane z warstwy prezentacyjnej dla warstwy komercyjnej. Z warstwy komercyjnej należy usunąć wszystkie referencje do obsługi żądań oraz do struktur danych warstwy prezentacyjnej, związanych z obsługą protokołu. Wartości należy przekazywać pomiędzy warstwami za pomocą ogólnych struktur danych. Rysunek 5.10. Wyodrębnienie kodu warstwy prezentacji z warstwy komercyjnej Motywacja Fragmenty kodu implementacji właściwe dla jednej warstwy nie powinny być umieszczane w innej warstwie. Interfejs API usługi, udostępniany przez warstwę komercyjną warstwie prezentacyjnej, będzie najprawdopodobniej wykorzystywany przez różnych klientów. Jeżeli 90 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu API usługi przyjmuje parametry szczegółowego typu, np. HttpServletRequest, to każdy klient będzie musiał hermetyzować dane w strukturach danych typu HttpServletRequest. To z kolei radykalnie zmniejsza możliwość wielokrotnego wykorzystania danej usługi. Mechanika n Wszystkie referencje do struktur danych warstwy prezentacji, zamieszczone w warstwie komercyjnej, należy zastąpić referencjami do bardziej ogólnych struktur i typów danych. n Chodzi tu zazwyczaj o zastąpienie metod warstwy komercyjnej przyjmujących parametry szczegółowego typu, np. HttpServletRequest, parametrami bardziej ogólnych typów, takich jak String, int czy też UserInfo. n W warstwie prezentacji należy zmodyfikować kod kliencki, który zawiera wywołania takich metod. n Do metod warstwy komercyjnej można przesyłać rozdrobnione struktury danych warstwy prezentacji. Jeżeli na przykład obiekt żądania HttpServletRequest ma parametry Z, [ oraz , to metoda w warstwie komercyjnej zamiast parametrów typu HttpServletRequest może przyjmować te trzy argumenty oddzielnie — jako parametry typu 5VTKPI. Wadą takiego przesyłania rozdrobnionych argumentów jest to, że technika ta zwiększa powiązania pomiędzy kodem warstwy prezentacji a API serwisu komercyjnego. Oznacza to, że przy zmianie stanu wymaganego przez usługę musi również zostać zmieniony API serwisu. n Nieco bardziej elastyczne rozwiązanie polega na skopiowaniu odpowiedniego stanu ze struktury danych warstwy prezentacji do bardziej ogólnych struktur danych, na przykład do obiektów przyjmujących wartość, które są potem przekazywane do warstwy komercyjnej. W takim przypadku API serwisu nadal przyjmuje obiekt tego typu, nawet jeżeli zmieniła się jego implementacja. n Inne rozwiązanie polega na implementacji strategii nałożenia typu interfejsu, jeżeli na przykład zastosowano szkielet warstwy prezentacji taki, jak często stosowany projekt Struts [Struts]. n Podczas obsługi żądania szkielety warstwy tworzą zazwyczaj szereg struktur danych. Polega to na przykład na tym, że szkielet kopiuje odpowiedni stan ze struktury danych typu HttpServletRequest do bardziej ogólnych struktur danych, dopasowując parametry żądania do typu danych właściwego dla określonego szkieletu. Chociaż wspomniany typ danych może spełniać taką samą funkcję, jaką spełnia obiekt posiadający wartość (typu ogólnego), to jednak jest to typ właściwy dla danego szkieletu. Oznacza to, że przesyłanie takiej struktury danych do warstwy komercyjnej wymaga wytworzenia ścisłej zależności pomiędzy szkieletem obsługującym żądania a serwisami komercyjnymi. Pewnym rozwiązaniem może być w tej sytuacji właśnie skopiowanie struktury danych właściwej dla szkieletu do bardziej ogólnej struktury, przed przekazaniem jej do warstwy komercyjnej. Bardziej wydajne jest jednak utworzenie ogólnego typu interfejsu, który będzie zawierał metody odpowiadające metodom typu właściwego dla szkieletu. Nałożenie takiego typu interfejsu na obiekt właściwy Rozdział 5. n Sposoby przebudowy J2EE 91 dla szkieletu umożliwi korzystanie z tego obiektu bez konieczności wytwarzania ścisłego powiązania z określonym szkieletem. n Jeżeli na przykład szkielet tworzy instancję podklasy obiektu CHTCOGYQTM/[5VCVG$GCP, to będzie ona typu 5VCVG$GCP: 7YCICVYQTGPKGKPUVCPELKQFD[YCUKúCY[ECLRQRTGRTGDWFQYú 7YCICFNCWRTQUEGPKCRQOKPKúVQRCTCOGVT[ CHTCOGYQTM5VCVG$GCPDGCPPGYO[UVWHH/[5VCVG$GCP   n Gdyby warstwa komercyjna przyjmowała przedstawiony komponent JavaBean jako parametr, byłby on typu 5VCVG$GCP: RWDNKEXQKFC4GOQVG$K6KGT/GVJQF CHTCOGYQTM5VCVG$GCPDGCP n Zamiast przekazywać komponent JavaBean typu 5VCVG$GCP do warstwy komercyjnej, należy utworzyć nowy interfejs, np. o nazwie my.stuff.MyStateVO, zaimplementowany przez obiekt O[UVWHH/[5VCVG$GCP: RWDNKEENCUU/[5VCVG$GCPGZVGPFUCHTCOGYQTM5VCVG$GCPKORNG;OGPVU/[5VCVG81 n W ten sposób w warstwie komercyjnej można użyć następującej sygnatury metody: RWDNKEXQKFC4GOQVG$K6KGT/GVJQF O[UVWHH/[5VCVG81DGCP n Nie ma potrzeby kopiowania parametrów do obiektu ogólnego typu, posiadającego wartość, a typ właściwy dla szkieletu nie jest już udostępniany w różnych warstwach jednocześnie. n Należy wreszcie zaznaczyć, że zależności pomiędzy logicznie niezwiązanymi ze sobą częściami można zredukować poprzez zastosowanie opisywanego tu sposobu przebudowy dla obiektów warstwy prezentacyjnej. n Ilustracja podobnego przykładu znajduje się na rysunku 5.11. Rysunek 5.11. Oddzielenie kodu warstwy prezentacji od obiektów domeny n Ponieważ należy zachowywać możliwość wielokrotnego użycia obiektów rodzimych, takich jak WUVQOGT, również w tym przypadku obowiązuje opisywana powyżej motywacja i mechanika. n Oznacza to, że referencje do struktur danych związanych z protokołem są skoncentrowane wokół komponentów obsługujących żądania, takich jak sterownik. Listingi 5.7 oraz 5.8, zamieszczone poniżej, pokazują, w jaki sposób można oddzielić obiekt *VVR5GTXNGV4GSWGUV od obiektu rodzimego. 92 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu Przykład Przedstawiona w listingu 5.7 klasa WUVQOGT przyjmuje jako parametr instancję obiektu do- meny *VVR5GTXNGV4GSWGUV, którego typ charakteryzuje się wysokim stopniem specjalizacji. Oznacza to, że klient spoza Internetu, który chce skorzystać z klasy WUVQOGT, musiałby naj- pierw utworzyć w jakiś sposób obiekt *VVR5GTXNGV4GSWGUV, a takich rozwiązań należy unikać. Listing 5.7. Ścisłe powiązanie obiektu domeny z obiektem HttpServletRequest  2QPKľU[HTCIOGPVMQFWWMCWLGQDKGMVTQFKO[ MVÎT[QUVCđD[VħEKħNGRQYKæCP[QDKGMVGO*VVR5GTXNGV4GSWGUV  RWDNKEENCUU WUVQOGT ] RWDNKE WUVQOGT *VVR5GTXNGV4GSWGUVTGSWGUV ] HKTUV0COGTGSWGUVIGV2CTCOGVGT HKTUVPCOG  NCUV0COGTGSWGUVIGV2CTCOGVGT NCUVPCOG  _ _ Zamiast udostępniać obiekt typu HttpServletRequest ogólnemu obiektowi WUVQOGT, należy je od siebie oddzielić, jak to pokazano w listingu 5.8. Listing 5.8. Oddzielenie obiektu domeny od obiektu HttpServletRequest 2T[MđCFQFFKGNGPKCQDKGMVWFQOGP[QFQDKGMVW*VVR5GTXNGV4GSWGUV; RWDNKEENCUU WUVQOGT ] RWDNKE WUVQOGT 5VTKPIHKTUV5VTKPINCUV ] HKTUV0COGHKTUV NCUV0COGNCUV _ _ Usuwanie konwersji z widoku Fragmenty modelu podlegają w komponencie widoku konwersji, która umożliwia ich wy- świetlenie. Cały kod konwersji należy usunąć z widoku, umieszczając go w jednej lub większej ilości klas pomocniczych. Rysunek 5.12. Usunięcie konwersji z widoku Rozdział 5. n Sposoby przebudowy J2EE 93 Motywacja Bezpośrednie osadzenie w widoku JSP kodu dokonującego konwersji modelu w celu jego wyświetlenia ogranicza modularność i możliwość wielokrotnego wykorzystywania aplikacji. Ponieważ tego rodzaju konwersje mogą być konieczne na wielu stronach JSP, kod konwersji w nich umieszczany musiałby się powtarzać, a utrzymanie takich stron polegałoby na pra- cochłonnym wycinaniu i wklejaniu fragmentów kodu. Mechanika n Za pomocą wzorca klasy wydobycia (Extract Class [Fowler]) oraz pomocnika widoku należy utworzyć klasy pomocnicze i przenieść do nich procedury konwersji z poszczególnych stron JSP. n Przykładem może być konwersja zbioru wyników z bazy danych do postaci tabeli HTML, w oparciu o odpowiedni kod aplikacji. n Klasy te należy udostępnić z poziomu stron JSP, dzięki czemu — w razie potrzeby — możliwe będzie dokonanie konwersji i adaptacji. n Konwersja jest przeprowadzana przez klasę pomocniczą, wywoływaną z poziomu strony JSP. Przykład W przedstawionym tu przykładzie zajmiemy się procedurą, która przeprowadza konwersję zbioru elementów (zbioru wyników z bazy danych) do postaci tabeli HTML. Jest to w pewnym sensie procedura formatowania, ale chodzi tu również o kod konwersji, generujący tabelę z modelu pośredniego. Kod takiej dynamicznej konwersji może być wielokrotnie wykorzy- stywany, jeżeli zostanie zaimplementowany w dodatkowo zdefiniowanych znacznikach, zamiast bezpośrednio w kodzie strony JSP. W listingu 5.9 przedstawiono stronę JSP, w której kodzie bezpośrednio zamieszczono pro- cedurę konwersji. Listing 5.9. Procedura konwersji umieszczona bezpośrednio w widoku JVON JGCF VKVNG .KUVCRTCEQYPKMÎYVKVNG JGCF DQF[ J JGCF EGPVGT .KUVCRTCEQYPKMÎYJ  5VTKPIHKTUV0COG  5VTKPI TGSWGUVIGV2CTCOGVGT HKTUV0COG  5VTKPINCUV0COG  5VTKPI TGSWGUVIGV2CTCOGVGT NCUV0COG  KH HKTUV0COGPWNN YTCKGRQVTGD[RQDTCPGQUVCPæYU[UVMKGGNGOGPV[ HKTUV0COG 94 Część II n Elementy projektów, niewłaściwe techniki oraz przebudowa systemu KH NCUV0COGPWNN NCUV0COG  ORNQ[GG GNGICVGGOR GNGICVGPGY  ORNQ[GG GNGICVG  +VGTCVQTGORNQ[GGU GOR GNGICVGIGV ORNQ[GGU  ORNQ[GG GNGICVG#..A 2#46/ 065   VCDNGDQTFGT VT VJ +OKúVJ VJ 0CYKUMQVJ VJ 5VCPQYKUMQVJ VT  YJKNG GORNQ[GGUJCU0GZV  ]  ORNQ[GG81GORNQ[GG ORNQ[GG81 GORNQ[GGUPGZV  KH GORNQ[GGIGV(KTUV0COG  UVCTVU9KVJ HKTUV0COG  GORNQ[GGIGV.CUV0COG  UVCTVU9KVJ NCUV0COG  ]  VT VF GORNQ[GGIGV(KTUV0COG VQ7RRGT CUG  VF VF GORNQ[GGIGV.CUV0COG VQ7RRGT CUG  VF VF GORNQ[GGIGV GUKIPCVKQP  VF VT  _ _  VCDNG Najpierw taki kod należy wyodrębnić w klasach pomocniczych. Klasy takie należy w tym przypadku zaimplementować w dodatkowo zdefiniowanych znacznikach, co umożliwi usu- nięcie możliwie największej ilości kodu skryptletu ze strony JSP. Następnie w kodzie strony JSP należy umieścić odwołania do klas pomocniczych, przeprowadzających konwersję. W listingu 5.10 przedstawiono stronę JSP po wprowadzeniu takich zmian. Listing 5.10. Wyodrębnienie procedury w klasach pomocniczych JVON JGCF VKVNG .KUVCRTCEQYPKMÎYRQRTGDWFQYKGVKVNG JGCF DQF[ J EGPVGT .KUVCRTCEQYPKMÎYJ EQTGRCVVGTPUGORNQ[GG#FCRVGT VCDNGDQTFGT Rozdział 5. n Sposoby przebudowy J2EE 95 VT VJ +OKúVJ VJ 0CYKUMQVJ VJ 5VCPQYKUMQVJ VT EQTGRCVVGTPUGORNQ[GGNKUVKFGORNQ[GGNKUV OCVEJ(KTUV0COG.CUV0COG VT VF EQTGRCVVGTPUGORNQ[GGCVVTKDWVG(KTUV0COG ECUG7RRGT VF VF EQTGRCVVGTPUGORNQ[GGCVVTKDWVG.CUV
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

J2EE. Wzorce projektowe
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ą: