Spis Treści SPIS TREŚCI........................................................................................................................................................ 1 ROZDZIAŁ 1. TWORZENIE DYNAMICZNYCH APLIKACJI INTERNETOWYCH............................. 6 CZYM BYŁA SIEĆ WWW ..................................................................................................................................... 6 Specyfikacja HTML 2 ..................................................................................................................................... 7 Specyfikacja HTML 3.2 .................................................................................................................................. 8 Specyfikacja HTML 4 ..................................................................................................................................... 8 ZAWARTOŚĆ STATYCZNA A ZAWARTOŚĆ DYNAMICZNA ...................................................................................... 8 TWORZENIE SKRYPTÓW PO STRONIE KLIENTA I PO STRONIE SERWERA............................................................... 10 Tworzenie skryptów po stronie klienta ......................................................................................................... 10 Tworzenie skryptów po stronie serwera ....................................................................................................... 14 SKŁADNIKI DYNAMICZNYCH ROZWIĄZAŃ INTERNETOWYCH ............................................................................. 17 Przejście przez stronę quizu ......................................................................................................................... 18 HTML ........................................................................................................................................................... 18 Składnik bazy danych ................................................................................................................................... 19 Komponenty serwera .................................................................................................................................... 22 Kod ASP (Active Server Page) ..................................................................................................................... 26 Współpraca z serwerem internetowym .................................................................................................... 28 NIE TYLKO IIS SYSTEMU NT ............................................................................................................................. 29 ROZDZIAŁ 2. SERWER IIS WIDZIANY Z PERSPEKTYWY TWÓRCY STRON ................................ 30 CZYM JEST IIS? ................................................................................................................................................. 30 OTRZYMYWANIE KOPII IIS ................................................................................................................................ 31 KONSOLA ZARZĄDZANIA MICROSOFTU ............................................................................................................. 31 WŁAŚCIWOŚCI USŁUG WWW............................................................................................................................ 33 Właściwości witryny WWW .......................................................................................................................... 34 Właściwości związane z wydajnością........................................................................................................... 36 Właściwości filtrów ISAPI............................................................................................................................ 37 Właściwości katalogu macierzystego ........................................................................................................... 37 Dokumenty.................................................................................................................................................... 38 Błędy klienta ................................................................................................................................................. 39 WITRYNY WWW W SERWERZE IIS ................................................................................................................... 40 DODAWANIE WITRYNY WWW .......................................................................................................................... 42 WŁAŚCIWOŚCI WITRYNY WWW ....................................................................................................................... 45 Wiele witryn pod jednym adresem IP........................................................................................................... 45 Zakładka właściwości witryny WWW........................................................................................................... 47 Właściwości katalogu macierzystego ........................................................................................................... 48 EKSPLORACJA WITRYNY .................................................................................................................................... 48 Katalogi wirtualne........................................................................................................................................ 49 Właściwości folderu i pliku .......................................................................................................................... 51 APLIKACJE ASP ................................................................................................................................................ 52 Zmienne trwałe i zakresowe ......................................................................................................................... 52 Zdarzenia...................................................................................................................................................... 53 Tworzenie aplikacji ASP .............................................................................................................................. 53
Spis Treści
2
Konfigurowanie aplikacji ASP ..................................................................................................................... 55 WITRYNY FTP................................................................................................................................................... 58 ROZDZIAŁ 3. NARZĘDZIA PRACY............................................................................................................. 60 PRZEGLĄD APLIKACJI DO TWORZENIA STRON .................................................................................................... 60 NOTATNIK ......................................................................................................................................................... 60 FRONTPAGE 2000.............................................................................................................................................. 62 Środowisko pracy ......................................................................................................................................... 62 Tworzenie sieci Web ..................................................................................................................................... 68 Przeglądanie strony...................................................................................................................................... 70 Dodawanie strony......................................................................................................................................... 71 Praca ze stroną............................................................................................................................................. 72 NETOBJECTS FUSION ......................................................................................................................................... 74 Środowisko pracy ......................................................................................................................................... 74 Tworzenie witryny WWW przy użyciu programu Fusion ............................................................................. 80 Praca ze stroną............................................................................................................................................. 80 NETOBJECTS SCRIPTBUILDER ........................................................................................................................... 81 Środowisko programowe .............................................................................................................................. 81 Praca z kodem w programie ScriptBuilder .................................................................................................. 87 Weryfikacja kodu w programie ScriptBuilder.............................................................................................. 92 MICROSOFT VISUAL INTERDEV 6.0................................................................................................................... 94 OSTATNIE SŁOWO O NARZĘDZIACH.................................................................................................................... 96 ROZDZIAŁ 4. PODSTAWY ASP .................................................................................................................... 97 KONSTRUKCJA KODU ASP................................................................................................................................. 97 Znacznik .................................................................................................................................. 97 .................................................................................................................... 98 ........................................................................................................................................ 99 < Script> Kod ........................................................................................................................... 100 HTML w kodzie .......................................................................................................................................... 101 SKRYPT W SKRYPCIE........................................................................................................................................ 103 Dyrektywa przetwarzania........................................................................................................................... 105 Pliki Include ............................................................................................................................................... 106 Po co ich używać .................................................................................................................................... 106 Włączanie pliku ...................................................................................................................................... 106 Plik Include — struktura i przykład ....................................................................................................... 107 Wywoływanie procedur ......................................................................................................................... 108 KOD ASP W UŻYCIU ........................................................................................................................................ 108 Komentarze, puste miejsca i wielkość liter ................................................................................................ 108 Zmienne ...................................................................................................................................................... 111 Typy danych................................................................................................................................................ 112 Zakres i trwałość ........................................................................................................................................ 113 Operatory ................................................................................................................................................... 114 Warunki ...................................................................................................................................................... 116 Pętle............................................................................................................................................................ 121 Konwersja zmiennych................................................................................................................................. 125 Funkcje daty i czasu ................................................................................................................................... 127 Zatwierdzanie obecności i typów danych ................................................................................................... 131 Techniki zatwierdzania danych .................................................................................................................. 133 Formatowanie liczb, dat i kwot pieniężnych .............................................................................................. 135 Operowanie ciągami .................................................................................................................................. 139 Liczby losowe ............................................................................................................................................. 145 Procedury ................................................................................................................................................... 146 ROZDZIAŁ 5. OBIEKT REQUEST.............................................................................................................. 148
3
ASP – Kompendium programisty
HIERARCHIA I MODELE OBIEKTÓW ASP .......................................................................................................... 148 Czym są hierarchie obiektów? ................................................................................................................... 148 Model obiektów ASP .................................................................................................................................. 149 ODBIERANIE INFORMACJI OD ODWIEDZAJĄCEGO ............................................................................................. 151 Zbiory obiektu Request ............................................................................................................................... 151 Zbiór Form.............................................................................................................................................. 151 Zbiór QueryString .................................................................................................................................. 154 Zbiór ServerVariables ............................................................................................................................ 157 Zbiór Cookies ......................................................................................................................................... 159 Zbiór ClientCertificate ........................................................................................................................... 160 WŁAŚCIWOŚĆ OBIEKTU REQUEST .................................................................................................................... 161 Właściwość TotalBytes ............................................................................................................................... 161 METODA OBIEKTU REQUEST ........................................................................................................................... 162 Metoda BinaryRead.................................................................................................................................... 162 OBIEKT REQUEST W DZIAŁANIU ...................................................................................................................... 163 Przykład certyfikatu klienta........................................................................................................................ 163 Procesor e-mail dla formularza ................................................................................................................. 168 Procesor bazy danych dla formularza........................................................................................................ 172 Witryna logowania ..................................................................................................................................... 174 ROZDZIAŁ 6. OBIEKT RESPONSE............................................................................................................ 180 WYSYŁANIE INFORMACJI DO GOŚCI ................................................................................................................. 180 ZBIÓR OBIEKTU RESPONSE .............................................................................................................................. 180 Zbiór cookie................................................................................................................................................ 181 WŁAŚCIWOŚCI OBIEKTU RESPONSE ................................................................................................................. 184 Właściwość Buffer ...................................................................................................................................... 184 Właściwość CacheControl ......................................................................................................................... 186 Właściwość Charset ................................................................................................................................... 186 Właściwość ContentType............................................................................................................................ 186 Właściwość Expires .................................................................................................................................... 187 Właściwość ExpiresAbsolute ...................................................................................................................... 188 Właściwość IsClientConnected .................................................................................................................. 190 Właściwość PICS........................................................................................................................................ 191 Właściwość Status ...................................................................................................................................... 192 METODY OBIEKTU RESPONSE .......................................................................................................................... 192 Metoda AddHeader .................................................................................................................................... 193 Metoda AppendToLog ................................................................................................................................ 193 Metoda BinaryWrite ................................................................................................................................... 193 Metoda Clear.............................................................................................................................................. 196 Metoda End ................................................................................................................................................ 196 Metoda Flush.............................................................................................................................................. 197 Metoda Redirect ......................................................................................................................................... 198 Metoda Write .............................................................................................................................................. 199 OBIEKT RESPONSE W DZIAŁANIU ..................................................................................................................... 199 Readresowanie i obiekt wyboru ................................................................................................................. 199 Pasek zaawansowania ................................................................................................................................ 203 Strona preferencji....................................................................................................................................... 207 ROZDZIAŁ 7. OBIEKT SERVER................................................................................................................. 212 WEJŚCIE NA SZCZYT ........................................................................................................................................ 212 WŁAŚCIWOŚĆ OBIEKTU SERVER ...................................................................................................................... 212 Właściwość ScriptTimeout ......................................................................................................................... 213 METODY OBIEKTU SERVER .............................................................................................................................. 214 Metoda CreateObject ................................................................................................................................. 215 Metoda HTMLEncode ................................................................................................................................ 218
Spis Treści
4
Metoda MapPath ........................................................................................................................................ 219 Metoda URLEncode ................................................................................................................................... 221 OBIEKT SERVER W DZIAŁANIU ........................................................................................................................ 222 Automatyzacja biura................................................................................................................................... 222 ROZDZIAŁ 8. OBIEKT SESSION, OBIEKT APPLICATION ORAZ PLIK GLOBAL.ASA............... 232 APLIKACJE ASP .............................................................................................................................................. 232 TWORZENIE APLIKACJI ASP ............................................................................................................................ 233 OBIEKT SESSION .............................................................................................................................................. 235 Zbiory obiektu Session................................................................................................................................ 235 Zbiór Contents ........................................................................................................................................ 235 Zbiór StaticObjects................................................................................................................................. 239 Właściwości obiektu Session ...................................................................................................................... 240 Właściwość CodePage............................................................................................................................ 241 Właściwość LCID .................................................................................................................................. 242 Właściwość SessionID ........................................................................................................................... 244 Właściwość TimeOut ............................................................................................................................. 244 Metoda obiektu Session .............................................................................................................................. 245 Metoda Abandon .................................................................................................................................... 245 OBIEKT APPLICATION ...................................................................................................................................... 246 Zbiory obiektu Application ......................................................................................................................... 246 Zbiór Contents ........................................................................................................................................ 246 Zbiór StaticObjects................................................................................................................................. 250 Metody obiektu Application........................................................................................................................ 251 Metoda Lock........................................................................................................................................... 251 Metoda Unlock ....................................................................................................................................... 253 PLIK GLOBAL.ASA............................................................................................................................................ 253 Zdarzenia pliku global.asa ......................................................................................................................... 255 Zdarzenie Application_OnStart.............................................................................................................. 255 Zdarzenie Application_OnEnd............................................................................................................... 259 Zdarzenie Session_OnStart .................................................................................................................... 259 Zdarzenie Session_OnEnd ..................................................................................................................... 261 Deklaracje obiektów w pliku global.asa................................................................................................. 263 APLIKACJE ASP W UŻYCIU .............................................................................................................................. 264 ROZDZIAŁ 9. OBIEKTY CDO DLA WINDOWS NT SERVER .............................................................. 266 UZUPEŁNIENIE STRONY ASP O FUNKCJĘ WYSYŁANIA WIADOMOŚCI E-MAIL ................................................... 266 OBIEKT NEWMAIL .......................................................................................................................................... 267 Właściwości obiektu NewMail.................................................................................................................... 268 Właściwość To ....................................................................................................................................... 268 Właściwość From ................................................................................................................................... 269 Właściwość Subject................................................................................................................................ 270 Właściwość Body ................................................................................................................................... 270 Właściwość CC ...................................................................................................................................... 273 Właściwość BCC.................................................................................................................................... 273 Właściwość Importance.......................................................................................................................... 274 Właściwości BodyFormat i MailFormat ................................................................................................ 275 Właściwości ContentBase i ContentLocation ........................................................................................ 278 Właściwość Value .................................................................................................................................. 279 Właściwość Version ............................................................................................................................... 280 Metody obiektu NewMail............................................................................................................................ 281 Metoda Send........................................................................................................................................... 281 Metoda AttachFile .................................................................................................................................. 282 Metoda AttachURL ................................................................................................................................ 284 Metoda SetLocaleID............................................................................................................................... 285
5
ASP – Kompendium programisty
OBIEKT NEWMAIL W DZIAŁANIU .................................................................................................................... 285 ROZDZIAŁ 10. SKŁADNIKI ASP ................................................................................................................ 287 OBIEKTY ZWIĘKSZAJĄCE MOŻLIWOŚCI STRON ASP......................................................................................... 287 SKŁADNIK BROWSER CAPABILITIES ................................................................................................................ 287 Modyfikacja pliku browser.ini.................................................................................................................... 295 SKŁADNIK AD ROTATOR ................................................................................................................................. 296 SKŁADNIK PAGE COUNTER.............................................................................................................................. 303 SKŁADNIK COUNTERS ..................................................................................................................................... 311 SKŁADNIK CONTENT LINKING ......................................................................................................................... 316 SKŁADNIK CONTENT ROTATOR ....................................................................................................................... 324 SKŁADNIK MYINFO ......................................................................................................................................... 328
Rozdział 1. Tworzenie dynamicznych aplikacji internetowych Czym była sieć WWW Przez minione lata Internet niesamowicie wpłynął na nasze życie. Światowa sieć jest teraz potężnym zlepkiem informacji. Obecnie kiedy chcemy poznać adres firmy lub nawet jej lokalizację, sprawdzamy to w Internecie. Chcesz wiedzieć jaka sztuka jest wystawiana w miejscowym teatrze? Sprawdź w Internecie. Musisz poznać ceny jakiegoś produktu? Zobacz w sieci WWW. Szukasz pracy w Des Moines? Znajdziesz ją na sieci. Ale sieć WWW nie była tak nasycona informacjami od samego początku. Podstawowym przeznaczeniem Internetu była wymiana informacji pomiędzy badaczami naukowymi. Stworzenie języka HTML (HyperText Markup Language) było podyktowane koniecznością znalezienia powszechnej formy prezentowania informacji na różnorodnych platformach i systemach operacyjnych. Komputery używane do przeglądania stron HTML miały zainstalowane programy klienckie oraz przeglądarki, które odczytywały i interpretowały kod HTML, a następnie przedstawiały jego interpretację osobie oglądającej stronę. Te podstawowe przeznaczenie pozostało siłą Internetu, choć drastycznie zmieniły się sposoby prezentowania informacji. Wczesna wersja strony WWW wyglądała podobnie jak ta pokazana na rysunku 1.1.
7
ASP – Kompendium programisty
Rysunek 1.1. Pierwotna wersja HTML Zauważ, że pierwsza wersja HTML zawierała jedynie podstawowe informacje, jak również miała możliwość odsyłania do innych dokumentów. Już wczesna wersja posiadała zdolność zignorowania tych znaczników, których nie potrafiła zrozumieć. Jest to w dalszym ciągu znacząca cecha HTML, z której twórcy stron korzystają przez cały czas. Ale w tej wersji z roku 1992 nie było możliwości prezentowania informacji graficznych, takich jak obrazy, tabele czy obiekty. Zauważ również, że nie było wtedy sposobu na uzyskanie informacji od osoby przeglądającej stronę WWW.
Specyfikacja HTML 2 Kolejna wersja HTML zawierała wspaniałe ulepszenia. Rysunek 1.2. pokazuje niektóre elementy, które mogła zawierać wersja 2 specyfikacji HTML.
Rysunek 1.2. Przykładowa strona stworzona przy wykorzystaniu HTML 2 Prawdopodobnie najważniejszymi nowymi składnikami HTML 2 były znaczniki tabeli, obrazu i formularza. Znacznik tablicy po raz pierwszy pozwolił na wyświetlenie informacji w postaci tabeli. Było to jednak jego pierwotne przeznaczenie. Szybko stał się spełnieniem marzeń tych twórców stron WWW, którzy potrzebowali lepszego rozmieszczenia elementów na stronie. Teraz twórcy stron często używają znaczników tabeli do precyzyjnego rozłożenia pozycji na stronie WWW. Znacznik obrazu pozwalał twórcom na dekorowanie swych stron. Mogli umieszczać na nich logo firmy, zdjęcia pracowników oraz zdjęcia okolicznościowe. Grafika również mogła być wykorzystywana do dekoracji układu strony. Dodatkowo używano małych, niewidocznych obrazków przy pomocy których rozmieszczano inne elementy strony WWW. Na przykład niektórzy twórcy stron używali pustych obrazków o określonym rozmiarze do zaznaczenia akapitu. Specyfikacja HTML 2 dodatkowo została wzbogacona w formularze. Przed użyciem formularzy kontakt z odwiedzającymi stronę był bardzo ograniczony. Dzięki formularzom i ich standardowym elementom możliwe stało się gromadzenie informacji o gościach pozwalających na udostępnianie im właściwej strony, gromadzenie informacji osobistych oraz dodawanie gości do listy dystrybucyjnej lub wielu innych aplikacji. Zawartość formularzy była udostępniana programom CGI (CGI — Common Gateway Interface) do przetwarzania w postaci strumienia bajtów. Programy CGI, zwykle pisane w PERL lub C, mogły dokonać analizy składniowej danych w strumieniu, przetwarzać je, aby później zwrócić wyjściowe informacje przeglądarce.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
8
Specyfikacja HTML 3.2 Kolejną znaczącą wersją HTML wydaną przez W3C Consortium była wersja 3.2, która już w niewielkim stopniu różniła się od tego, czym HTML jest dzisiaj. Do istniejących znaczników dodano liczne parametry i unowocześnienia, jak również wprowadzono nowe znaczniki, z których najważniejszym był znacznik apletu. Znacznik apletu pozwalał twórcom na włączenie aplikacji Javy wprost do ich stron WWW. Takie dodatki jak aplety Javy mogły być pełnymi aplikacjami realizującymi różnorakie zadania. Mogłeś stworzyć przy ich użyciu wysuwane obrazki, które odsyłały gości do różnych miejsc, kiedy kliknęli jeden z nich. Mogłeś mieć aplet Javy prezentujący uaktualnione dane na temat cen produktów. Mogłeś napisać applet Javy będący programem do rysowania dla dzieci. Liczba aplikacji, dla których znacznik ten był wykorzystywany była wielka, co spowodowało znaczny rozrost sieci WWW.
Specyfikacja HTML 4 HTML 4 jest bieżącą wersją wydaną przez W3C Consortium. Znaczącymi dodatkami tej specyfikacji są znaczniki obiektu, skryptu oraz formularza stylów. Znacznik formularza stylów pozwala na tworzenie wspólnych stylów dla elementów strony WWW. Kiedy styl zostaje zdefiniowany, może zostać przeniesiony na inną stronę. Pozwala to na przykład na jednorazowe zdefiniowanie koloru, rozmiaru i czcionki nagłówka. Następnie ten styl może zostać zastosowany na wielu innych stronach. Jeśli konieczna jest zmiana stylu nagłówka, należy jej dokonać tylko w jednym miejscu, w definicji elementu, a zmiana ta zostanie przeniesiona na inne strony korzystające z tego znacznika. Znacznik skryptu pozwala na włączenie kodów zwanych skryptami po stronie klienta (client-side scripts). Oznacza to, że w HTML wbudowano kod, który jest uruchamiany przez przeglądarkę zainstalowaną na komputerze klienta. Przyjrzymy się skryptom po stronie klienta nieco dalej w tym rozdziale, podczas omawiania zalet i wad tego rodzaju tworzenia skryptów. Kolejnym znaczącym ulepszeniem w tej wersji jest włączenie do niej znacznika obiektu, który dostarcza mechanizmów pozwalających na umieszczenie multimediów i innych obiektów w granicach strony WWW. Na przykład znacznik obiektu może być wykorzystany podczas odwiedzania witryny grupy dyskusyjnej w celu stworzenia na twoim komputerze potokowego wejścia audio-wideo, jak również można go użyć przy przeglądaniu trójwymiarowego elementu zamieszczonego na stronie i możliwego do obejrzenia po zainstalowaniu odpowiedniego plug-inu w przeglądarce.
Zawartość statyczna a zawartość dynamiczna Wcześniej większość zawartości Internetu stanowiły składniki statyczne, to znaczy, że odwiedzając jakąś stronę WWW za każdym razem mogłeś spodziewać się dokładnie tej samej treści. Te same teksty, grafiki, formatowanie, po prostu wszystko. Aby zmienić zawartość strony twórca musiał ręcznie modyfikować tekst strony i ponownie umieszczać ją w Internecie. Wykorzystywanie tej techniki powodowało, że sieć WWW była nieco skostniała. Użytkownicy sieci mogli odwiedzić twoją stronę raz lub dwa, lecz jeśli jej treść nie zmieniała się, prawdopodobnie kolejne odwiedziny były wymuszone. W ostatnich latach twórcy stron zdali sobie sprawę z tego, że statyczna zawartość to trochę za mało. Coraz więcej firm zaczęło wystawiać zawartość dynamiczną przynajmniej w części swoich witryn WWW. Obecnie znalezienie dużej witryny, która nie zawiera jakiegoś składnika dynamicznego to wydarzenie naprawdę niezwykłe. Dynamiczna zawartość WWW to pojęcie odnoszące się do stron, których treść zmienia się przez cały czas. Na przykład strona pokazana na rysunku 1.3. ukazuje jedno z ustawień strony, kiedy aktualny dzień przypada na weekend, zaś kiedy aktualny dzień tygodnia to poniedziałek, wtorek, środa, czwartek lub piątek, wtedy strona wyświetli zawartość pokazaną na rysunku 1.4.
ASP – Kompendium programisty
9
Rysunek 1.3. Próbna strona o zawartości wyświetlanej w czasie weekendów
Rysunek 1.4. Ta sama próbna strona pokazująca zawartość wyświetlaną w tygodniu Jak widzisz zawartość strony z rysunku 1.4. jest dynamiczna. Jej treść może się zmieniać przez cały czas. Zmiana może następować po każdorazowym przeglądnięciu strony lub w losowych bądź stałych odstępach czasowych. Te zmiany to znacząca kwestia. Tworzenie takich dynamicznych aplikacji internetowych to główny temat tej książki. Kod wymagany podczas tworzenia zawartości dynamicznej może być zaimplementowany przez rozmaite mechanizmy. Kod poprzedniego przykładu był stworzony w VBScript na stronie ASP. Pokazany został poniżej.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
10
Jest weekend idź do domu! Rzuć surfing i do pracy!
Nie przejmuj się tym, jeśli nie potrafisz przeczytać tego kodu teraz; szczegóły poznamy w kolejnych rozdziałach książki. Jednak powyższy kod nie musiał być napisany wykorzystując ASP przy użyciu VBScript. Mógł być zaimplementowany przez składnik napisany w C++ lub przez biblioteki filtrujące wyszukujące strony z określonymi rozszerzeniami i przetwarzające je odpowiednio. Mógł być również napisany w JavaScript. W następnym podrozdziale zobaczysz, że kod może zostać napisany zarówno po stronie klienta, jak i po stronie serwera.
Tworzenie skryptów po stronie klienta i po stronie serwera Tworzenie skryptów po stronie klienta Tworzenie skryptów w tym kontekście to pojęcie odnoszące się do miejsca, w którym kod jest przetwarzany. Tworzenie skryptów po stronie klienta oznacza, że kod jest uruchamiany na komputerze klienta (bezpośrednio w przeglądarce). Kiedy odwiedzający chce przeglądnąć stronę, HTML i każdy inny kod strony jest pobierany przez przeglądarkę odwiedzającego. Następnie przeglądarka dokonuje analizy składniowej i realizuje każdy rozpoznany kod strony. Rezultaty tych czynności przeglądarka pokazuje odwiedzającemu stronę. Przykładem może być tutaj grafika pokazana na rysunku 1.5. o treści „Welcome to NetStats2000 — NetStats Live”.
Rysunek 1.5. Przykładowa grafika zrealizowana po stronie klienta. Teraz spójrz na tą samą stronę, kiedy kursor myszy znajduje się ponad wspomnianą grafiką, jak pokazano na rysunku 1.6. Zauważ, że teraz treść grafiki brzmi „Click here to contact us”. Jest to realizowane przez kod po
ASP – Kompendium programisty
11
stronie klienta. Przeglądarka wczytuje każdy kod i przetwarza go. W tym przykładzie kod napisany został w JavaScript i przedstawia się następująco: <SCRIPT LANG="Javascript">= 3 )) || ((navigator.appName == "Microsoft Internet Explorer") && (parseInt(navigator.appVersion) >= 4 ))) version = "ok", else version = "x", if (version == "ok") { img6off = new Image(); img6off.src = "./assets/images/baroff.jpg"; img6on = new Image(); img6on.src = "./assets/images/baron.jpg"; } function imgover(imgName) {
if (version == "ok") {
document[imgName].src = eval(imgName + "on.src");
}
}
function imgoff(imgName) {
if (version == "ok") {
document[imgName].src = eval(imgName + "off.src");
}
}
// –>
Rysunek 1.6. Ta sama strona z kursorem myszy znajdującym się nad obrazkiem Następnie w elemencie obrazka mamy poniższy kod korzystający z poprzednich funkcji i zmiennych:
Zauważ, że kod jest otoczony znacznikami skryptu, które informują przeglądarkę o typie zastosowanego kodu. Jednak bardzo ważną okolicznością jest fakt, że nie wszystkie przeglądarki rozpoznają dany kod. Wobec tego co się stanie, kiedy przeglądarka, która nie rozpoznaje znacznika skryptu, próbuje dokonać analizy składniowej strony? Cały blok zostanie zignorowany, ponieważ nie rozpoznane znaczniki są pomijane. W tym przykładzie nie ma to znaczenia. Jeśli goście nie zobaczą naszej palety— grafiki pojawiającej się podczas przesuwania kursorem myszy nad obrazkiem — nie zmieni to rzeczywistej funkcjonalności strony. Spójrzmy jednak na kolejny przykład, w którym pominięcie bloku może nie być takie proste (Rysunek 1.7).
Rysunek 1.7. Przykładowy skrypt strony klienta używający pola zatwierdzenia W tym przykładowym skrypcie strony klienta korzystamy z kodu zatwierdzającego wejście użytkownika, zanim odwiedzający będzie mógł wystawić żądanie dostępu. Jeśli użytkownik zostawi to pole nie wypełnione, ujrzy wiadomość pokazaną na rysunku 1.8.
Rysunek 1.8. Wiadomość, która ukaże się tym odwiedzającym stronę, którzy nie wypełnią przedłożonego pola zatwierdzenia Gdy odwiedzający wpisze w pole wartość, jest ona zatwierdzana, a użytkownik zostaje odesłany do strony odpowiadającej tej wartości. Kod realizujący zatwierdzanie jest następujący: <SCRIPT language="JavaScript">
ASP – Kompendium programisty
13 { for (var i=0; i
Kod dla przycisku Submit Request:
Pamiętaj co się stanie, kiedy przeglądarka nie rozpozna znacznika skryptu lub języka użytego w skrypcie. Cały kod znajdujący się pomiędzy znacznikami skryptu zostanie zignorowany, tak więc strona stanie się bezużyteczna dla przeglądarek, które nie obsługują tych skryptów. Odwiedzający zobaczy stronę, ale po naciśnięciu przycisku Submit Request nic się nie stanie. Jest to ryzyko, które musisz rozważyć. Oczywiście tworzenie skryptów po stronie klienta ma swoje korzyści. Ponieważ przetwarzanie odbywa się po stronie klienta, twój serwer ma mniej pracy, mniejsza liczba przywołań redukuje ruch w sieci, a odwiedzający stronę nie musi czekać na dodatkowe wywołania twojej przeglądarki. Istnieje również pewne niebezpieczeństwo. Cały twój kod jest ujawniany gościom strony, jeśli więc zechcą oni poznać kod źródłowy strony przy pomocy menu opcji swojej przeglądarki, ujrzą każdy jego wiersz.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
14
Tworzenie skryptów po stronie serwera Głównym tematem tej książki jest tworzenie skryptów po stronie serwera. Ponownie będziemy zajmować się miejscem uruchamiania kodu. Podczas pisania skryptów po stronie klienta kod uruchamiany jest przez przeglądarkę zainstalowaną na komputerze odwiedzającego stronę. Podczas tworzenia skryptów po stronie serwera kod, zanim zostanie wysłany do przeglądarki gościa, przetwarzany jest najpierw na serwerze. Użytkownicy uzyskują dostęp do strony WWW przez wpisanie jej nazwy w oknie przeglądarki lub klikając odpowiednie łącze. Serwer internetowy otrzymuje żądanie dostępu, a następnie wyszukuje stronę. Każdy kod strony serwera jest wtedy przetwarzany, a strona WWW może zostać zwrócona w czystej postaci HTML. Przeglądarka dokonuje analizuje składniowej podstawowego języka HTML i prezentuje jej rezultat odwiedzającemu. W ten sposób tworzenie skryptów po stronie serwera nie wymaga od przeglądarki specjalnych możliwości. Nie musi ona wiedzieć jak przeczytać dany rodzaj skryptu, ponieważ przetwarzanie odbywa się na serwerze, który zwraca jedynie podstawową postać HTML. Chroniony jest również twój kod. Często zdarza się, że nie chcesz udostępniać całemu światu twojego kodu źródłowego. Kod może być prawnie zastrzeżony dla twojej firmy lub może zawierać ukryte informacje systemowe, które nie powinny być dostępne dla osób postronnych. Tworzenie skryptów po stronie serwera rozwiązuje ten problem dzięki zwracaniu nie samego kodu, lecz jedynie rezultatu wykonania kodu. Jeśli więc użytkownik żąda dostępu do strony, która zawiera kod logowania do bazy danych, nie musisz mu pokazywać schematu działania twoich zapytań, nazw pól, techniki zatwierdzania, itd. Przy przetwarzaniu po stronie serwera, odwiedzający stronę poznaje jedynie wynik działania kodu. Spójrzmy na kilka przykładów wykorzystania skryptu strony serwera. Strona pokazana na rysunku 1.9. zawiera standardowy formularz logowania firmy. Zatwierdza ona wejście użytkownika na fikcyjną stronę WWW. Strona pozwala gościom na wprowadzenie nazwy użytkownika oraz hasła. Jeśli wprowadzą niewłaściwe hasło, ujrzą stronę, którą prezentuje rysunek 1.10.
Rysunek 1.9. Pierwszy widok strony logowania
ASP – Kompendium programisty
15
Rysunek 1.10. Przykładowa witryna logowania wyświetlająca wiadomość o próbie niewłaściwego wejścia Odwiedzający otrzymują wiadomość o tym, że wprowadzona informacja nie została rozpoznana. Jeśli wprowadzą wartość poprawną, wyświetli się strona pokazana na rysunku 1.11.
Rysunek 1.11. Tekst widoczny na stronie logowania po udanym wejściu. Strona logowania jest implementowana jako pojedyncza strona ASP. Poniżej pokazano jej kod. Również w tym przypadku nie musisz przejmować się tym, że nie rozumiesz jeszcze wszystkich jego szczegółów — po prostu przeczytaj go pobieżnie. Później omówimy tego typu kody dość obszernie.
Po pierwsze kod sprawdza, czy naciśnięty został przycisk Log On. Jeśli tak, kod zweryfikuje nazwę użytkownika i jego hasło z rekordami bazy danych. Jeśli taki zapis istnieje oznacza to, że użytkownik wprowadził właściwe wartości i ukaże się odpowiednia wiadomość. Gdyby rekord nie został odnaleziony, wyświetlona zostałaby inna wiadomość mówiąca o niepoprawnym wejściu. Ostatnia wiadomość zawiera treść, jaką pierwotnie zawierała strona. Pomyśl o tym, co by się stało, gdybyś próbował to zaimplementować po stronie klienta. Po pierwsze mogłoby to działać jedynie pod ostatnimi wersjami Internet Explorer, ponieważ kod został zapisany w VBScript. Kolejnym problemem mógłby być fakt ujawnienia hasła bazy danych w kodzie źródłowym podczas wysyłania go do przeglądarki. Przy korzystaniu ze skryptu po stronie serwera nie mamy takich zmartwień. Kod zostanie przetworzony przez serwer i żaden z bloków kodu nie będzie widoczny dla odwiedzających; dodatkowo nie musimy martwić się o to, z jakiej przeglądarki oni korzystają, ponieważ przeglądarka otrzymuje jedynie wynik w postaci HTML. Kolejną dużą zaletą tworzenia skryptów po stronie serwera jest możliwość korzystania przez serwer ze składników, które mogą być nieosiągalne na komputerze klienta. Przykładowo załóżmy, że chcę na mojej stronie WWW stworzyć kalkulator obliczający kwotę spłaty pożyczki. Mógłby on wyglądać tak, jak to pokazuje rysunek 1.12.
17
ASP – Kompendium programisty
Rysunek 1.12. Przykładowa strona kalkulatora obliczającego kwotę spłaty pożyczki Odwiedzający stronę wpisywaliby potrzebne do obliczeń dane. Po naciśnięciu przycisku Calculate kodowaliby obliczenie kwoty spłaty na podstawie wprowadzonych parametrów. Jak widzieliśmy, istnieje wiele możliwości wyboru miejsca ulokowania tego kodu oraz sposobu jego implementacji. Teraz już wiesz, że kod jest lepiej chroniony przed nielegalnym skopiowaniem przez innego twórcę stron, jeśli piszesz skrypty po stronie serwera. Wiesz, że nie musisz martwić się o to, czy przeglądarka będzie w stanie właściwie zinterpretować napisany przez ciebie kod. Ale ponadto jeszcze trzecia korzyść płynie z tej formy tworzenia skryptów. Jeśli kiedykolwiek próbowałeś tworzyć od zera kalkulator obliczający kwotę spłaty pożyczki to wiesz, że to żmudna i narażona na wiele błędów praca. Dlaczego nie skorzystać ze składników (komponentów) znajdujących się na twoim serwerze, które wykonują obliczenia dla ciebie? Na przykład Microsoft Excel potrafi wykonywać wiele obliczeń finansowych. Możesz wykorzystać te komponenty w skrypcie po stronie serwera i uniknąć w ten sposób powielania kodu, który już posiadasz. Tak więc tworząc skrypty po stronie serwera możesz wykorzystać funkcje składników serwera na potrzeby aplikacji nie martwiąc się o to, czy odwiedzający stronę posiadają odpowiednie składniki na swoich komputerach.
Składniki dynamicznych rozwiązań internetowych Do tej pory zastanawialiśmy się co decyduje o tym, że strona WWW jest statyczna lub dynamiczna. Przyjrzeliśmy się różnym sposobom tworzenia stron dynamicznych, jak również ich wadom i zaletom. W tym podrozdziale zwrócimy uwagę na różnorodne składniki tworzące dynamiczne rozwiązania i sposoby ich współdziałania. Rozwiązanie dynamiczne może zawierać rozmaite składniki. Po pierwsze, HTML. Nawet najbardziej dynamiczna strona posiada jakiś statyczny składnik HTML wiążący ze sobą elementy dynamiczne. Często dynamiczna strona lub witryna zawiera bazę danych, której treść jest również dynamiczna. Bardziej zaawansowane rozwiązania łączą w sobie wszystkie składniki, które znajdują się na serwerze. Niejednokrotnie elementy te zawierają przepisy firmowe i pośredniczą między bazą danych a częściami dynamicznymi strony WWW. Mogą posiadać również jakiś rodzaj kodu, który wstawia w stronę treść dynamiczną, jak to jest w przypadku kodu ASP. Zwykle też rozwiązania dynamiczne będą wykorzystywały jakiś serwer WWW, na przykład internetowy serwer informacyjny, w celu odebrania żądania od przeglądarki, przetworzenia kodu na stronie i zwrócenia rezultatu.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
18
Przejście przez stronę quizu Aby zademonstrować jak funkcjonuje każdy ze składników rozwiązania dynamicznego, na kilku kolejnych stronach zaprezentowano przykładowy quiz. Używa on języka HTML dla statycznych elementów strony. Korzysta z bazy danych w celu zapamiętywania pytań i odpowiedzi. Składnik Visual Basic realizuje wezwania bazy danych pozwalające na wyszukiwanie pytań i sprawdzanie poprawności odpowiedzi. Strona quizu implementowana jest jako strona ASP i zawiera kod dynamicznego wyświetlania w oparciu o aktualne pytania; znajduje się ona na internetowym serwerze informacyjnym, który przetwarza kod i zwraca jego wynik przeglądarce. Quiz wykonany jest jako pojedyncza strona WWW. Kiedy użytkownicy odwiedzą ją po raz pierwszy, ujrzą widok przedstawiony na rysunku 1.13. Kiedy rozpoczną quiz, zobaczą pytanie pierwsze. Wybiorą odpowiedź, którą uważają za prawidłową i nacisną przycisk Check Answer. Wtedy ukaże się strona pokazana na rysunku 1.14. Proces ten powtarza się dopóki użytkownicy nie odpowiedzą na ostatnie pytanie quizu, po którym ukaże się im strona przedstawiona na rysunku 1.15. Rysunek 1.13. Pierwsza strona quizu Rysunek 1.14. Drugie pytanie quizu Rysunek 1.15. Ostatnia strona quizu Zauważ, że po zakończeniu quizu odwiedzający stronę nie mają żadnych dodatkowych pytań ani nie widać już przycisku odpowiedzi na pytanie. Jak dowiesz się z dalszego omówienia, kod ASP steruje tym wyjściem na stronie.
HTML W tym dynamicznym środowisku internetowym, HTML jest połączeniem dowolnego statycznego składnika pierwotnego żądania oraz wyjścia kodu uruchamianego na serwerze. Kiedy więc odwiedzający stronę poproszą o pierwsze pytanie quizu, otrzymają w odpowiedzi sam HTML. Przykładowo, chociaż pytania quizu są elementem dynamicznym, opartym na aktualnym żądaniu pytania, wyjściowym elementem jest następujący kod HTML:
With this type of scripting, the code runs in the browser.
Lista rozwijana obiektu sterującego wyborem zawiera możliwe odpowiedzi na zadane pytania, a jeśli odwiedzający zdecyduje się na obejrzenie kodu źródłowego strony, może przykładowo zobaczyć: <SELECT NAME="Answer" > Server-Side Client-Side
Faktycznie z punktu widzenia odwiedzającego, ta pojedyncza witryna zdaje się być czterema osobnymi stronami: po jednej na każde pytanie plus jedna końcowa. HTML w tym przykładzie obejmuje też formularz, który jest zgrupowaniem elementów HTML takich jak pola tekstowe (również niesformatowane, zwane Textarea), obiekty sterujące wyborem, przyciski opcji oraz pola sprawdzające. W naszym przykładzie formularz jest pojedynczym obiektem sterującym wyborem, który zawiera zbiór możliwych odpowiedzi na pytania. Ale formularz posiada również wiele innych obiektów sterujących, które zawierają ukryte wartości. Elementy ukryte niosą w sobie wartości, które chcesz przedłożyć wraz z
ASP – Kompendium programisty
19
formularzem, ale nie chcesz, aby były one widoczne dla odwiedzających stronę. W kolejnej stronie przykładu użyte zostały trzy ukryte elementy.
Pierwszy ukryty element zawiera numer bieżącego pytania. Potrzebujemy tej wartości w celu sprawdzenia, czy odwiedzający wybrał właściwą odpowiedź na to pytanie. Element ukryty Question zapamiętuje liczbę pytań, na które odpowiedział gość. Wartość NumberCorrect informuje o liczbie poprawnych odpowiedzi. Te trzy ukryte wartości oraz wartość obiektu wyboru, które zawierają odpowiedź użytkownika na dane pytanie, są przedkładane wraz z formularzem po naciśnięciu przycisku Check Answer. Oznacza to, że przeglądarka wysyła te pola w postaci strumienia bajtów pod adres określony w znaczniku formularza:
Tak więc wartości są wysyłane z powrotem do tej samej strony, która wcześniej stworzyła omawianą stronę — oto w jaki sposób uzyskujemy wiele stron z jednej. Za każdym razem kiedy odwiedzający odpowiadają na pytanie, numer pytania wraz z odpowiedzią i dwoma innymi wartościami jest wysyłany z powrotem do tej samej strony w celu przetworzenia. Jeszcze jedna rzecz jest przekazywana wraz ze stroną podczas jej przedkładania. Jest to nazwa naciśniętego przycisku:
Często będziesz spotykał się z tym kodem w dalszych częściach książki oraz sam będziesz używał go przy tworzeniu twoich własnych kodów. Wykrywanie naciśnięcia tego lub jakiegokolwiek innego przycisku służy określeniu działań, jakie należy podjąć. Kiedy strona jest przetwarzana, na stronie znajduje się czysty HTML tuż obok jej kodu. Na przykład, na nieprzetworzonej stronie obiekt sterujący wyborem, który został opisany wcześniej, wygląda następująco: <SELECT NAME="Answer" >
A HTML z kodem strony nieprzetworzonej dla elementów ukrytych przedstawia się tak:
W dalszej części tego rozdziału przyjrzymy się jak kod ASP współpracuje z HTML w celu realizacji dynamicznego wyświetlania zawartości.
Składnik bazy danych Wiele rozwiązań internetowych i intranetowych, które stworzysz, będzie zawierało w sobie jakiś rodzaj bazy danych. Kiedy logujesz użytkowników twojej witryny, będziesz potrzebował tabeli użytkowników, która będzie wykorzystywana podczas zatwierdzania ich wejść. Jeśli posiadasz firmowy katalog online, prawdopodobnie będzie on składał się z tabel zawierających informacje o produktach: ich nazwy, opis, dostępność, ceny, zalety itd. Jeśli na twojej stronie znajdują się informacje o aktualnych warunkach
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
20
atmosferycznych w twoim miejscu zamieszkania, dane do wyszukiwania zapewne przechowywane są w bazie danych. Tak więc baza danych dynamicznej aplikacji internetowej często zawiera kod źródłowy dla dynamicznej zawartości. W naszym przykładowym projekcie quizu żądania dla bazy danych pochodzą od strony ASP. Żądanie przechodzi przez komponent serwera, który wystosowuje zapytania do bazy danych. Baza danych zwraca żądanie do komponentu serwera, który następnie przesyła dane z powrotem do naszej strony ASP. Jak się dowiesz dokładniej z rozdziału 13., kod żądania dostępu do danych bazy, zarówno na stronie ASP jak i w składniku serwera, musi znać położenie bazy danych. Aby to osiągnąć, można skorzystać z Otwartego łącza baz danych (ODBC — Open Database Connectivity). Poprzez Administratora źródeł danych ODBC (rysunek 1.16.) stworzymy Nazwę źródła danych (DSN — Data Source Name). Klikając przycisk Dodaj (Add) możemy skonfigurować połączenie z każdą osiągalną bazą danych, dla której mamy sterownik ODBC.
Rysunek 1.16. Administrator źródeł danych ODBC W tej przykładowej witrynie łączymy się z bazą danych SQL Server 6.5 zwaną ASPBook. Stworzona zostaje nazwa DSN w celu zapewnienia komunikacji pomiędzy SQL Server a stroną ASP. Kiedy to połączenie jest tworzone po raz pierwszy, zapamiętywany jest typ i nazwa bazy danych oraz adres IP serwera. Niektóre z tych elementów widać na rysunku 1.17.
21
ASP – Kompendium programisty
Rysunek 1.17. Konfiguracja nazwy DSN ODBC. Dane w bazie naszego przykładu z quizem zawierają tekst pytania, prawidłową odpowiedź na nie oraz wszystkie inne możliwe odpowiedzi, które zostaną wyszczególnione w obiekcie wyboru strony WWW. Używa się dwóch tabeli dostarczających potrzebnych danych. Pierwsza z nich zwana jest C1Questions; zawiera ona dane samego pytania. Nazwy pól, typów i ich zastosowania pokazano w tabeli 1.1. Tabela 1.1. Pola C1Questions Nazwa pola Typ pola Przeznaczenie QuestionID int Klucz główny Question varchar Tekst pytania Answer varchar Tekst poprawnej odpowiedzi QuestionID jest kluczem podstawowym dla tabeli. Oznacza to, że zawiera wartość, która jest unikalna dla tego pola. Jeśli więc któryś rekord posiada pole QuestionID o wartości 45, nie może jej mieć żaden inny rekord. Ta niepowtarzalność daje nam możliwość odczytywania właściwych odpowiedzi w kodzie. Typ danych to int, czyli wartość pola musi być liczbą całkowitą. Pole Question zawiera treść samego pytania. Ta dana jest wyświetlana na stronie WWW jako pytanie. Typ danych w tym wypadku to varchar, co znaczy, że w polu tym mogą znaleźć się litery wraz z cyframi. Długość pola może wynosić od 0 do 255 znaków. Pole Answer zawiera prawidłową odpowiedź na pytanie. To pole tekstowe używane jest do sprawdzania poprawności odpowiedzi podawanej przez biorących udział w quizie. Pole może zawierać od 0 do 100 znaków. Druga tabela, z której korzysta nasza przykładowa strona z quizem, zawiera wszystkie możliwe odpowiedzi na zadane pytania. Nazywa się C1Answers, a jej pola opisuje tabela 1.2. Tabela 1.2. Pola C1Answers Nazwa pola Typ pola Przeznaczenie AnswerID int Klucz główny i kolumna tożsamości QuestionID int Klucz obcy Answer varchar Tekst poprawnej odpowiedzi Dane w tabeli 1.2. są wykorzystywane do wypełnienia obiektu sterującego wyborem na stronie WWW. Do każdego pytania można przyporządkować jedną lub kilka odpowiedzi znajdujących się w tabeli. W kodzie prosimy tabelę o znalezienie odpowiedzi przyporządkowanych do aktualnego pytania, a następnie wyświetlamy je w obiekcie wyboru.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
22
Pole AnswerID jest kluczem głównym tabeli. Jak wspomniano wcześniej klucz główny jednoznacznie identyfikuje każdy rekord tabeli. Pole jest również określane pojęciem kolumny tożsamości. To znaczy, że podczas dodawania do tabeli nowego rekordu możesz zostawić to pole puste, a SQL Server wypełni je automatycznie niepowtarzalną wartością. Jak się dowiemy z rozdziału 13., tworząc pola takie jak te w SQL Server, możesz określić numer początkowy i sposób inkrementacji tego numeru dla kolejnych rekordów. Pole QuestionID używane jest jako klucz obcy tabeli, to znaczy będzie wykorzystywany do połączenia pomiędzy tabelami C1Questions i C1Answers. Kiedy wypełniamy obiekt wyboru możliwymi odpowiedziami, nie chcemy widzieć odpowiedzi na inne pytania, interesują nas jedynie dostępne odpowiedzi na bieżące pytanie. To pole umożliwia taką filtrację. Kiedy odpowiedź jest wprowadzana do tabeli, musi zostać również wprowadzona wartość pola QuestionID. To ostatnie pole odnosi się do właściwego pytania związanego z tą odpowiedzią. Ostatnie pole tej tabeli to pole Answer, które zawiera samą treść odpowiedzi. Ta dana trafia do obiektu sterującego wyborem. Jeden z rekordów tabeli C1Questions pokazuje tabela 1.3. Przykładowy rekord C1Answers prezentuje tabela 1.4. Tabela 1.3. Przykładowy rekord tabeli C1Questions Nazwa pola Wartość QuestionID 1 Question Przy tym sposobie pisania skryptów kod uruchamiany jest w przeglądarce. Answer Po stronie klienta Tabela 1.4. Przykładowy rekord tabeli C1Answers Nazwa pola Wartość AnswerID 1 QuestionID 1 Answer Po stronie serwera
Komponenty serwera Nie wszystkie twoje rozwiązania internetowe i intranetowe potrzebują komponentów serwera. Tak naprawdę na samym początku możesz nie używać ich wcale. Ale z upływem czasu zorientujesz się, że niektórych rozwiązań nie uda ci się zrealizować od ręki stosując jedynie technologię ASP; być może stwierdzisz, że kod ASP staje się zbyt skomplikowany i należy podzielić go na obiekty; lub może rozdzielisz te różnorodne zadania pomiędzy programistów klasy podstawowej a tych bardziej zaawansowanych. Wykorzystanie czy utworzenie komponentu serwera często zaspokaja wiele wymagań. Komponenty serwera są modułami kodowymi, do których uzyskujesz dostęp poprzez twój kod ASP lub z innych środowisk programowych w celu realizacji pewnych zadań związanych z programowaniem. Niektóre z tych składników wbudowane są w twój system. Na przykład IIS (Internet Information Server) jest dostarczany wraz z CDO (Collaborative Data Objects) ułatwiającymi wysyłanie poczty elektronicznej poprzez twój kod, co zostanie omówione w rozdziale 9. Kolejny składnik dostarczany wraz z IIS to Browser Capabilities, który to komponent używany jest do określania typu przeglądarki i innych informacji dotyczących gości strony (więcej informacji znajdziesz w rozdziale 10). Inne składniki można zakupić lub pobrać ze stron sprzedawców. Te produkty są zazwyczaj bardziej wyspecjalizowane w swoich zadaniach. Jeśli na przykład wystąpi potrzeba stworzenia kodu grafiki ukazującej diagram kołowy, znajdziesz odpowiednie ku temu składniki. Często możesz oszczędzić sobie mnóstwa czasu i pieniędzy dzięki zakupieniu składnika wspierającego programowanie. Inną możliwością jest stworzenie własnych składników. Można w ten sposób zaspokoić różnorodne potrzeby, w tym również wydajność. Gdy tworzysz nowy składnik zaimplementowany w postaci kompilowanego kodu, który różni się od kodu skryptu ASP tym, że musisz go przekompilować za każdym razem, kiedy go używasz. Innym ważnym powodem tworzenia składników jest oddzielenie od siebie części strony poświęconej sprawom firmowym od interfejsu twoich aplikacji. Załóżmy, że musisz stworzyć witrynę, która dodawałaby informacje o nowych pracownikach do bazy danych. Możesz tego dokonać na wiele różnych sposobów. Możesz stworzyć
23
ASP – Kompendium programisty
aplikację dostępu dla działu zasobów ludzkich twojej firmy, przez którą będzie się wprowadzać zapisy do bazy danych. Możesz również użyć w tym celu aplikacji ASP. Baza danych prawdopodobnie jest skonfigurowana w ten sposób, że pewne pola wymagają wypełnienia, inne muszą być określonego typu i zasięgu. Te zasady, zasady firmowe, mogą być modyfikowane o wiele łatwiej i dokładniej, jeśli są umieszczone osobno. Komponent serwera zazwyczaj jest implementowany w ten sposób. Dodatkowym powodem tworzenia komponentów serwera jest pozbawienie niedoświadczonych programistów dostępu do pewnych złożonych bloków kodu. Możesz na przykład stworzyć procedurę obliczającą pewną przewidywaną wartość na podstawie zbioru parametrów i kalkulacji. Ten kod mógłby być umieszczony we wszystkich miejscach, które z niego korzystają. Ale programista, który nie jest z nim odpowiednio zaznajomiony mógłby korzystać z niego w niewłaściwy sposób. Jeśli stworzysz składnik serwera, umożliwisz swoim programistom wykonanie obliczeń dzięki jednemu połączeniu. W rozdziale 10. omówimy szczegółowo komponenty serwera, tutaj natomiast ograniczymy się jedynie do ich wprowadzenia. Na potrzeby strony z quizem, stworzony został komponent przez kompilację ActiveX DLL w Visual Basicu. Ten składnik realizuje interfejs między bazą danych a naszym kodem podstawowym, ASP. Tworzy się go poprzez wybranie projektu ActiveX DLL w oknie Visual Basic, co pokazano na rysunku 1.18.
Rysunek 1.18. Tworzenie ActiveX DLL w Visual Basic Kiedy zaznaczymy ikonę ActiveX DLL, konfigurujemy szablon do tworzenia składnika serwera biblioteki DLL. Szczególne znaczenie ma tutaj nazwa projektu, ponieważ będzie ona używana w naszym kodzie ASP w celu wywoływania procedur komponentu serwera. Robi się to przez wybranie Właściwości projektu (Project Properties) z menu Projekt (Project). Ukaże się okno dialogowe pokazane na rysunku 1.19, gdzie wpiszesz nazwę projektu w pole tekstowe Nazwa projektu (Project Name).
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
24
Rysunek 1.19. Nadawanie nazwy składnikowi serwera Wewnątrz ActiveX DLL znajdują się klasy, w których procedury faktycznie działają. Ilość klas nie jest ograniczona. Klasy tworzy się zazwyczaj przez umieszczenie razem tych procedur, które mają wspólne przeznaczenie. Na przykład komponent serwera naszej strony z quizem posiada jedną klasę. Klasa ta zawiera procedury wyszukiwania pytania i sprawdzania odpowiedzi. Lecz jeśli rozszerzymy tą aplikację, będziemy mogli dodać strony pozwalające użytkownikom na uzupełnianie quizu o własne pytania. Procedury realizujące takie zadania znajdowałyby się prawdopodobnie w osobnej klasie. Być może chciałbyś dodać kolejną klasę, która pozwalałaby użytkownikom logować się w aplikacji quizu w celu śledzenia jej rozwoju. Procedury realizujące tą funkcję znajdowałyby się zapewne w osobnej klasie. Podobnie jak w wypadku projektu, klasa również posiada swą nazwę. Nazwa klasy jest ważna, ponieważ będzie wykorzystywana przez nasz kod ASP do wywoływania procedur znajdujących się na serwerze. Używając Visual Basic nazwę klasy określić możesz we właściwościach klasy pokazanych na rysunku 1.20.
Rysunek 1.20. Nadawanie nazwy klasie
ASP – Kompendium programisty
25
Teraz, kiedy zdefiniowaliśmy już nasz komponent oraz klasę, jesteśmy gotowi do stworzenia procedury bądź metody wewnątrz klasy. Metody są blokami kodu napisanymi po to, aby realizować pewne zadania programowe. Są one wywoływane z kodu ASP, co zostanie omówione później. Klasa o nazwie Quiz, którą stworzyliśmy poprzednio posiada trzy metody. Pierwsza z nich wyszukuje tekst pytania w oparciu o pole QuestionID przekazywane przez procedurę. Kod procedury jest następujący: Public Function GetQuestion(QuestionID) Dim RSQuestion As ADODB.Recordset Set RSQuestion = Conn.Execute("select Question from C1Questions " _ & "where QuestionID = " & QuestionID) If RSQuestion.EOF Then GetQuestion = "NA" Else GetQuestion = RSQuestion("Question") End If End Function
Zauważ, że metoda ta nosi nazwę GetQuestion. Tej nazwy będziemy używać w kodzie ASP do wywoływania procedury. Kod tej funkcji łączy się z bazą danych i wyszukuje w niej tekst pytania w oparciu o pole QuestionID. Jeśli pole to nie jest właściwe, zwracany jest tekst NA; w przeciwnym wypadku zwracany jest tekst pytania. Kolejna procedura zwraca tekst możliwych odpowiedzi do wypełnienia obiektu wyboru w formularzu HTML. Kod tej procedury: Public Function GetAnswer(QuestionID) Dim RSAnswers As ADODB.Recordset Dim TempList As String Set RSAnswers = Conn.Execute("select Answer from C1Answers " _ & "where QuestionID = " & QuestionID) Do Until RSAnswers.EOF TempList = TempList & "" _ & RSAnswers("Answer") & "" RSAnswers.MoveNext Loop GetAnswer = TempList End Function
Ta metoda nosi nazwę GetAnswer. Kiedy jest wywoływana, przekazywane zostaje pole QuestionID. W bazie danych wyszukiwane są wszystkie możliwe odpowiedzi na dane pytanie. Następnie kod przechodzi kolejno lub w pętli przez każdą z opcjonalnych odpowiedzi znajdujących się w obiekcie sterującym wyborem, budując odpowiedni tekst HTML. Formatem zwracanym przez metodę jest czysty HTML. Ostatnią metodą klasy Quiz serwera o nazwie SampleServer jest procedura CheckAnswer. Sprawdza ona poprawność udzielonej odpowiedzi. Kod procedury: Public Function CheckAnswer(QuestionID, AnswerText) Dim RSAnswer As ADODB.Recordset Set RSAnswer = Conn.Execute("select Answer from C1Questions " _ & "where QuestionID = " & QuestionID) If RSAnswer("Answer") = AnswerText Then CheckAnswer = 1 Else CheckAnswer = 0
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
26
End If End Function
Procedura CheckAnswer korzysta z dwóch wartości: pola QuestionID oraz Answer w celu sprawdzenia poprawności odpowiedzi. Kod łączy się z bazą danych przeszukując ją w celu odnalezienia poprawnej odpowiedzi na konkretne pytanie. Następnie ta odpowiedź jest porównywana z odpowiedzią przekazywaną przez procedurę. Jeśli obydwie są takie same, procedura zwraca wartość 1, jeśli tak nie jest — wartością wyjściową jest 0. Te wartości oraz inne zwracane przez procedury będą wykorzystane przez kod ASP, co omówiono dalej. Klasa, którą tworzymy w Visual Basic, posiada miejsce pozwalające nam na określenie aplikacji, którą chcemy uruchomić, kiedy po raz pierwszy klasa jest wywoływana, innymi słowy kiedy tworzona jest jej kopia. To miejsce nazywane określane jest mianem Inicjacji zdarzenia i zawiera następujący kod: Private Sub Class_Initialize() Conn.Open "ASPBook", "sa", "yourpassword" End Sub
Ten kod zapewnia nam połączenie z bazą danych. Pamiętaj o tym, że musieliśmy skonfigurować nazwę DSN, jak to omawialiśmy w podrozdziale poświęconym bazie danych. Jedna z linii powyższego kodu korzysta z nazwy DSN, dzięki której możliwe jest połączenie z bazą danych. Inne procedury tej klasy używają tego połączenia podczas wyszukiwania danych.
Kod ASP (Active Server Page) Do tej pory przyglądaliśmy się czystemu kodowi HTML wysyłanemu do przeglądarki, jak również jego statycznemu wykorzystywaniu na naszej dynamicznej stronie. Przyjrzeliśmy się bazie danych zawierającej pytania i odpowiedzi quizu, jak również składnikom stworzonym w Visual Basic, używanym podczas łączenia z bazą. Teraz zwrócimy uwagę na kod ASP. Kod ASP jest odczytywany i przetwarzany przez serwer IIS, kiedy nasi goście odwiedzają stronę. Ten kod kompletuje wywołania potrzebne do stworzenia odpowiedniego wyjścia dla przeglądarki. W naszym przykładzie quizu kod musi wyszukiwać pytania i odpowiedzi. Musi również obserwować aktualne pytanie oraz liczbę poprawnych odpowiedzi oraz zadanych pytań. Kod powinien też formatować stronę w ten sposób, aby pole odpowiedzi i przycisk nie ukazywały się po zakończeniu quizu. Szczegółowo omówimy układ tego kodu w rozdziale 4., a na razie przyjrzymy się mu tylko pobieżnie. Na początku strony ASP mamy następujący kod:
Pierwsza linia kodu informuje kompilator o rodzaju języka użytego podczas tworzenia skryptu, w tym przypadku jest to VBScript. Następnie tworzymy kopię klasy na serwerze, co opisane zostało w poprzednim podrozdziale. Innymi słowy łączymy się ze składnikiem serwera, ponieważ chcemy wykorzystać procedury znajdujące się na nim: set objQuiz = server.CreateObject("SampleServer.Quiz")
Zauważ, że kiedy stworzyliśmy procedurę, użyliśmy nazw projektu i klasy — SampleServer.Quiz. Przypomnij sobie podrozdział dotyczący HTML, gdzie omawialiśmy sposób określania działań, które należy podjąć przy użyciu przycisku Submit Request. To samo realizuje poniższy kod: if isempty(Request.Form("Calculate")) then
Oznacza to, że jeśli odwiedzający nie nacisnął przycisku Calculate, to musiał wejść na stronę. Jeśli wystąpi taki przypadek, będziemy musieli skonfigurować stronę pierwszego pytania: CurrentQuestion = 1 QuestionsTaken = 0 NumberCorrect = 0
Jeśli przycisk Calculate jest naciśnięty, wtedy odwiedzającym przedstawiane są pytania, na które należy odpowiedzieć: Else
Następnie kod wywołuje składnik sprawdzający, czy nasi goście wpisali poprawną odpowiedź. Jeśli tak, musimy wyświetlić potwierdzenie poprawności: if objQuiz.CheckAnswer(Request.Form("CurrentQuestion"), _ Request.Form("Answer")) = 1 then NumberCorrect = Request.Form("NumberCorrect") + 1
W przeciwnym razie, aktualna liczba (NumberCorrect) oznacza ilość udzielonych do tej pory poprawnych odpowiedzi: else NumberCorrect = Request. Form("NumberCorrect")
Teraz musimy wyszukać tekst kolejnego pytania poprzez wywołanie procedury GetQuestion ze składnika serwera: QuestionText = obj.Quiz.GetQuestion(CurrentQuestion)
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
28
Jeśli pytanie nie zostało znalezione, procedura zwraca wartość NA, jak to określiliśmy w poprzednim podrozdziale. if QuestionText = "NA" then
Oznacza to, że powinniśmy przedstawić odwiedzającym wiadomość informującą o zakończeniu quizu: TheMessage = "Quiz: Complete"
W innym razie wyszukaliśmy odpowiednie pytanie, a odpowiedzi na nie muszą zostać znalezione przez procedurę GetAnswer: else TheMessage = "Quiz: In Progress" AnswerText = objQuiz.GetAnswer(CurrentQuestion)
end if
Po całym HTML rozsiane są dodatkowe linie skryptu, które wstawiają zmienne stworzone wcześniej. Na przykład tekst pytania napisany w HTML przedstawia się następująco:
Odpowiedzi dla obiektu sterującego wyborem są napisane w następującej linii kodu: <SELECT NAME="Answer" >
A rejestr punktacji dla odwiedzającego jest napisany w HTML w następujący sposób:
Score out of
Tak więc ASP realizuje naprawdę ważne zadania! Współpraca z serwerem internetowym Wszystkie poprzednie kody ściśle współpracują z serwerem internetowym. Serwer czeka na żądania dostępu od przeglądarki. Serwer wyszukuje żądaną stronę. Zależnie od typu strony, serwer internetowy sprawdzi również kod ASP. Jeśli taki kod znajduje się na stronie, serwer go przetworzy i połączy się z każdym składnikiem, którego kod ASP potrzebuje. Kiedy przetwarzanie zostaje zakończone, serwer internetowy wyśle HTML do przeglądarki. W naszym przykładzie korzystaliśmy z internetowego serwera informacyjnego (IIS) Microsoftu w systemie operacyjnym Windows NT. Kiedy ktoś w Internecie lub naszym Intranecie żąda dostępu do pliku quiz.asp, serwer IIS wyszukuje tą stronę. IIS zauważa, że strona ma rozszerzenie .asp. W ten sposób jest informowany o tym, że dana strona jest wykonana w technologii ASP i należy przetworzyć jej kod. Serwer IIS uruchamia ten kod na naszej stronie quizu. Tworzy kopie klasy o nazwie Quiz z serwera SampleServer. Następnie wynik w postaci HTML wysyła do tej przeglądarki, która żądała dostępu do strony. W następnym rozdziale dokładniej przyjrzymy się serwerowi IIS. Dowiemy się, jak konfigurować i wykorzystywać ten serwer z perspektywy twórcy strony.
29
ASP – Kompendium programisty
Nie tylko IIS systemu NT Tematem głównym tej książki jest korzystanie z technologii ASP na serwerze systemu Windows NT dzięki uruchamianiu IIS. Ale popularność ASP powoduje, że szybko wychodzi ona poza te ramy. Liczne firmy wytwarzają narzędzia i dodatki dla innych serwerów internetowych i systemów operacyjnych, co pozwala twórcom stron ASP pracować również poza modelem Microsoftu. W nadchodzących latach spodziewamy się kontynuacji rozwoju technologii ASP i przejęcia zasadniczej roli w zapewnianiu połączenia pomiędzy klientem a serwerem.
Rozdział 2. Serwer IIS widziany z perspektywy twórcy stron Czym jest IIS? Internet Information Service (IIS) firmy Microsoft jest połączeniem pomiędzy klientem a serwerem używanym w rozwiązaniach korzystających z przeglądarek internetowych i intranetowych. W tym typie rozwiązań pojęcie klient oznacza przeglądarkę, na przykład Microsoft Internet Explorer, Netscape Navigator czy jakąś inną. Serwer oznacza kombinację narzędzi i aplikacji, których używamy do tworzenia zawartości strony. W przypadku niektórych serwisów WWW zadania IIS będą ograniczały się do wysyłania statycznych bloków HTML; gdzie indziej IIS będzie odgrywał znacznie większą rolę, ułatwiając komunikację pomiędzy mnóstwem zasobów na twoim serwerze. Rysunek 2.1 pokazuje kolejne kroki żądania dostępu w tym środowisku klient-serwer. Omówimy ten proces dokładniej w rozdziale 4, teraz przyjrzyjmy się jedynie udziałowi serwera IIS. Użytkownicy wpisują w swojej przeglądarce żądanie dostępu do strony znajdującej się na twoim serwerze. Żądanie jest przesyłane przez Internet do twojego serwera, a następnie do IIS. IIS wyszukuje żądaną stronę, a następnie, w oparciu o nazwę znalezionego pliku decyduje o tym, co należy z nią zrobić. Jeśli plik ma rozszerzenie oznaczające konieczność przetworzenia go przez twój komputer, np. .asp, to IIS przetworzy kod tej strony.
Rysunek 2.1. Kolejne kroki generowania żądania przez przeglądarkę To przetwarzanie może dotyczyć również innych składników. Jeśli kod wymaga połączenia z SQL Server w celu wyszukania jakiejś danej, tworzona jest kopia potrzebnych składników. Kiedy kod potrzebuje jakiegoś programu graficznego do wygenerowania wykresu, odpowiedni składnik jest uruchamiany. Kiedy kod wywołuje jeden z twoich własnych składników, również zostanie stworzona jego kopia. Wynik kodu i wszystkie składniki pobrane dla tej strony są wysyłane z powrotem do przeglądarki, która żądała dostępu do strony. Następnie przeglądarka dokonuje analizy składniowej przysłanego kodu i wyświetla zawartość strony. Jeśli strona nie ma rozszerzenia lub nazwy, która wskazywałaby na konieczność
31
ASP – Kompendium programisty
przetworzenia jej przez IIS, jest ona po prostu wysyłana do przeglądarki bez kopii składników oraz bez jakiegokolwiek przetworzenia.
Otrzymywanie kopii IIS Internetowy serwer informacyjny wersji 4.0 systemu Windows NT 4.0 jest dostarczany wraz z pakietem Option Pack systemu operacyjnego. Pakiet ten możesz pobrać za darmo z witryny WWW Microsoftu. Nowe kopie płyt CD z Windowsem NT również zawierają serwer IIS 4.0, możesz więc już mieć IIS uruchomiony na twoim serwerze — będziesz bowiem potrzebował przynajmniej wersji 4.0. Poprzednie wersje nie pozwalały na wykorzystanie wszystkich narzędzi i technik przedstawionych w tej książce. To, czy posiadasz zainstalowany Pakiet opcji Windowsa NT 4.0, możesz sprawdzić przeglądając odpowiedni folder, co pokazano na rysunku 2.2.
Rysunek 2.2. Folder Pakietu opcji Windows NT 4.0 Instrukcje dotyczące pełnej instalacji IIS również znajdują się na stronie internetowej Microsoftu. Dalsza część tego rozdziału dotyczy konfiguracji IIS z perspektywy twórcy stron. Nauczysz się pracy z Konsolą zarządzania Microsoftu, konfiguracji usługi WWW, dodawania kolejnych witryn, współpracy z aplikacjami ASP, stosowania i konfigurowania usługi FTP oraz monitorowania sprawności twojego internetowego serwera informacyjnego.
Konsola zarządzania Microsoftu Konsola zarządzania Microsoftu (MMC — Microsoft Management Console) jest narzędziem używanym do konfiguracji IIS. MMC jest nowym elementem Windowsa NT używanym również podczas konfiguracji wielu innych zadań administracyjnych w środowisku NT. Narzędzie to działa przy użyciu modułów dodatkowych dla każdej aplikacji, która wykorzystuje konsolę MMC. MMC stanowi szkielet do konfiguracji usług. Produkt wymagający od administratora użycia MMC podczas konfiguracji, dostarcza modułu dodatkowego do MMC. Moduł dodatkowy (ang. snap-in) prezentuje hierarchiczny widok obiektów programu usługowego wraz z działaniami, które można podjąć dla każdego z nich. Aby wywołać konsolę MMC dla IIS, wybierz Menedżera usług internetowych z IIS firmy Microsoft pokazanego na rysunku 2.2, a wtedy zobaczysz konsolę zarządzania pokazaną na rysunku 2.3.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
32
Rysunek 2.3. Konsola zarządzania MMC z modułem dodatkowym IIS w użyciu Po lewej stronie znajduje się moduł dodatkowy IIS prezentujący listę hierarchiczną obiektów. Rozwijania i zwijania listy dokonujesz podobnie jak w oknie Eksploratora Windows, przez kliknięcie znaków plus lub minus. Kiedy klikniesz jeden z obiektów po lewej stronie okna, po prawej ukażą się wszystkie znajdujące się w nim pozycje. Każdy obiekt może zawierać działania (akcje), które podejmuje się dla tego obiektu. Możesz przeglądnąć listę działań dla obiektu wybierając go i klikając przycisk Działanie (Action) znajdujący się w pasku narzędziowym, co pokazano na rysunku 2.4.
Rysunek 2.4. Menu Działanie w konsoli MMC
33
ASP – Kompendium programisty
Każdy obiekt posiada również Właściwości (Properties), które są atrybutami obiektu. Aby przejrzeć właściwości obiektu, kliknij obiekt prawym przyciskiem myszy i wybierz Właściwości (Properties). Przeglądu właściwości możesz dokonać również klikając przycisk Działanie (Action) i wybierając Właściwości (Properties) lub naciskając ikonę Właściwości (Properties) w pasku narzędziowym. Moduł dodatkowy w pasku narzędziowym zapewnia również realizację innych funkcji, które nie odnoszą się do określonego obiektu. Na przykład możesz przejrzeć zawartość Monitora wydajności lub Programu przeglądu zdarzeń, wybierając odpowiednią ikonę na pasku narzędziowym.
Właściwości usług WWW Internetowy serwer informacyjny zawiera w sobie między innymi usługę WWW. Ta usługa ma właściwości, które możesz modyfikować wpływając na sposób jej konfiguracji. Usługa ta zawiera wiele właściwości, które są również właściwościami danej witryny WWW. Kiedy tworzysz nową witrynę WWW, właściwości użyte przy jej tworzeniu są dziedziczone przez usługę WWW, tak więc konfiguracja usługi już na samym początku oszczędzi ci mnóstwa czasu i pracy, jeśli na twoim serwerze znajduje się wiele witryn WWW. Aby otworzyć okno właściwości Usługi WWW w konsoli MMC, kliknij prawym przyciskiem myszy nazwę komputera zawierającego tą usługę, którą chcesz skonfigurować, a następnie wybierz Właściwości (Properties). Zobaczysz okno dialogowe pokazane na rysunku 2.5.
Rysunek 2.5. Dialog wyboru Właściwości głównych Zwróć uwagę na pole wyboru Umożliwiaj dławienie przepustowości (Enable Bandwidth Throttling). Jeśli zaznaczysz to pole, udostępnione zostanie pole tekstowe znajdujące się poniżej. Możesz w nim określić wartość przepustowości sieci, którą chcesz wykorzystać dla usługi. Ta wartość jest wartością maksymalną, a nie zarezerwowanym poziomem przepustowości — oznacza to, że niezależnie od dostępnego aktualnie pasma przepustowości, twoja usługa może zająć maksymalnie taką jej wartość, jaką określono w polu tekstowym.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
34
Właściwości witryny WWW W polu Właściwości główne (Master Properties) wybierz Usługę WWW i kliknij przycisk Edytuj (Edit). Teraz powinieneś ujrzeć okno dialogowe właściwości głównych dla Usługi WWW, jak to pokazano na rysunku 2.6.
Rysunek 2.6. Właściwości Usługi WWW Upewnij się, czy poruszasz się po zakładce o nazwie Witryna WWW (Web Site). Pierwszą rzeczą, jaką możesz tam wprowadzić jest opis usługi. Nie ma on wpływu na funkcjonowanie usługi, a służy jedynie twojej własnej identyfikacji. W samym środku okna właściwości możesz skonfigurować połączenia. Tutaj możesz zezwolić na równoczesne połączenie z twoim serwerem IIS nieograniczonej liczby odwiedzających lub możesz ją ograniczyć. Możesz również określić Czas rozłączenia (Connection Timeout). Wartość ta określa czas (w sekundach), przez który użytkownik może pozostawać nieaktywny przed przerwaniem połączenia z twoją usługą WWW. W dolnej części okna właściwości możesz zdecydować, czy chcesz umożliwić rejestrację, a jeśli tak, to jaki ma być jej typ. Rejestracja w Usłudze WWW pozwala na śledzenie poczynań użytkownika na twojej witrynie. Jeśli opcja rejestracji jest zaznaczona, każde żądanie dostępu od serwera WWW jest odnotowywane jako kolejna pozycja w bazie danych lub pliku tekstowym. Wprowadzane zapisy mogą zawierać datę i czas dostępu, adres IP komputera wysyłającego żądanie, plik będący obiektem zainteresowania i wiele więcej. Posiadasz cztery możliwości wyboru formatu dziennika zdarzeń: format pliku dziennika serwera IIS Microsoftu, wspólny format NCSA, rozszerzony format W3C oraz format dziennika ODBC. Format pliku dziennika zdarzeń serwera IIS Microsoftu jest specyficznym formatem używanym jedynie przez IIS. Plik dziennika jest tekstowym plikiem ASCII. Kiedy klikniesz właściwości pliku tego typu, możesz wybrać jego lokalizację i określić częstość generowania nowego pliku. Wspólny format pliku dziennika NCSA jest spotykany na serwerach internetowych, które nie należą do świata Microsoftu. Możesz potrzebować tego typu formatu podczas korzystania z niezależnego narzędzia analizy pliku dziennika. Rozszerzony format pliku dziennika zdarzeń W3C jest podobny do poprzedniego formatu NCSA, ale posiada dodatkowe pola wykorzystywane podczas śledzenia. Możesz również wybrać, w których polach chcesz gromadzić informacje, a w których nie. Jeśli naciśniesz przycisk Właściwości (Properties) dla tego typu
ASP – Kompendium programisty
35
dziennika, ujrzysz okno Rozszerzonych właściwości rejestracji (Extended Logging Properties), pokazane na rysunku 2.7.
Rysunek 2.7. Okno dialogowe Rozszerzonych właściwości rejestracji Klikając zakładkę Rozszerzone właściwości (Extended Properties) zobaczysz różne pola z nazwami zdarzeń, które możesz obserwować. Pole Nazwa użytkownika (User Name) jest prezentowane tylko wtedy, gdy dana osoba aktualnie jest zarejestrowana na twoim serwerze. Jeśli stroną odwiedzoną przez użytkownika na twojej witrynie była http://www.somewhere.com/search.asp?query=VB, adresem URL byłaby tutaj część www.somewhere.com/search.asp, a query=VB — polem zapytania URI. Pole Agent użytkownika (User Agent) zawiera informacje o przeglądarce, która wystosowała żądanie dostępu. Pole Odsyłacz (Referrer) zawiera nazwę strony, którą poprzednio odwiedził użytkownik, jeśli posiadała ona łącze ze stroną aktualnie odwiedzaną, z którego skorzystał użytkownik oraz jeśli przeglądarka obsługuje to pole. Jeśli żądany element strony to grafika, wtedy pole odsyłacza będzie obejmowało nazwę strony, na której ta grafika się znajduje. Czwartym typem rejestracji jest rejestracja ODBC, która najbardziej obciąża zasoby, ale daje ci wspaniałe możliwości analizy. Podczas rejestracji ODBC każde żądanie dostępu do twojego serwera jest odnotowywane w bazie danych. Korzystasz z właściwości dla tego typu rejestracji w celu określenia nazwy DSN bazy danej, której będziesz używał. Musisz najpierw stworzyć tabelę, w której będą umieszczane zapisy żądań. Tabela ta musi być określonego formatu, jak to opisano dla SQL Server w tabeli 2.1. Tabela 2.1. Definicje pól tabeli rejestracji ODBC Nazwa pola Wartość ClientHost Username LogTime Service Machine ServerIP ProcessingTime BytesRecvd BytesSent ServerStatus Win32Status Operation
varchar(255) varchar(255) datetime varchar(255) varchar(255) varchar(50) int int int int int varchar(255)
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
36
Target varchar(255) Parameters varchar(255) Po stworzeniu tabeli, będziesz musiał określić nazwę DSN poprzez Administratora źródeł danych ODBC, do którego następnie stworzysz odniesienie w oknie dialogowym rejestracji ODBC. Zobacz rozdział 13, w którym znajdziesz dodatkowe informacje na temat tworzenia nazw DSN. Przypis
Ponieważ rejestracja wymaga się zapisywania żądań do pliku lub bazy danych, korzysta się z zasobów. Jeśli nie używasz rejestracji, zasoby te możesz wyłączyć.
Właściwości związane z wydajnością Wybierz zakładkę Wydajność (Performance) w oknie Właściwości usługi WWW (WWW Service Properties), a zobaczysz okno przedstawione na rysunku 2.8.
Rysunek 2.8. Właściwości wydajności usługi WWW Dostrajanie wydajności (Performance Tunning) określa szacunkową liczbę połączeń w ciągu dnia. Nie musisz ustalać maksymalnego poziomu przewidywanych połączeń, jeśli nie jest ich zbyt wiele, ponieważ wtedy nie wykorzystasz odpowiednio twoich zasobów. Zauważ, że pole wyboru Umożliwiaj dławienie przepustowości (Enable Bandwidth Throttling) jest niedostępne. Ta właściwość może być ustawiona jedynie dla konkretnej witryny WWW. Omówimy tą właściwość później, w podrozdziale „Właściwości witryny WWW”. Kiedy zaznaczone jest pole Umożliwiaj sprawdzenie aktywności HTTP (HTTP Keep-Alive Enable), przeglądarka może podtrzymywać połączenie przez kolejne żądania dostępu do strony zamiast zestawiać połączenie za każdym razem, kiedy pojawia się nowe żądanie dostępu. To pole jest zaznaczone domyślnie.
37
ASP – Kompendium programisty
Właściwości filtrów ISAPI Jedną z najbardziej zaawansowanych funkcji IIS jest tworzenie filtrów ISAPI (ISAPI Filters), które pozwalają na podjęcie własnych, dostowanych do twoich potrzeb działań podczas wystąpienia niektórych zdarzeń związanych z IIS. Zamiast zwykłego przetworzenia zdarzenia przez serwer IIS, możesz wybrać inny program, który zajmie się tym zdarzeniem. Takie programy często napisane są w Visual C++ i również często umożliwiają dostosowanie procesu rejestracji. Jeśli więc nie odpowiadają ci formaty rejestracji omówione we wcześniejszym podrozdziale, możesz stworzyć swój własny. Aby to uczynić musisz dodać filtr ISAPI w odpowiednim oknie zakładki. pokazanym na rysunku 2.9. Kliknij przycisk Dodaj (Add) i przeglądnij pliki biblioteki. Kolejność pojawiania się tych filtrów jest znacząca, ponieważ pierwszy znaleziony filtr zajmujący się zdarzeniem jest uruchamiany przed wszystkimi innymi. Kiedy pliki te zostaną załadowane, pozostają w pamięci, uważaj więc, aby nie zostały nadużyte.
Rysunek 2.9. Okno dialogowe filtrów ISAPI
Właściwości katalogu macierzystego Następnie przeanalizujmy właściwości Katalogu macierzystego (Home Directory), które pokazane zostały na rysunku 2.10.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
38
Rysunek 2.10. Właściwości katalogu macierzystego usługi WWW Zauważ, że niektóre punkty okna są niedostępne, ponieważ nie mają one zastosowania w odniesieniu do usługi WWW, są natomiast omówione nieco dalej w tym rozdziale podczas analizy właściwości witryn WWW oraz aplikacji ASP. Kiedy ustawiasz właściwości usługi WWW pamiętaj, że tworzone przez ciebie witryny WWW będą dziedziczyć te właściwości — bądź więc ostrożny. Uprawnienia dostępu (Access permissions) określają, co anonimowy użytkownik może zrobić z plikami. Kiedy wybrano pole Odczyt (Read), może on jedynie przeglądać pliki. Jeśli zaznaczono kratkę Zapis (Write), odwiedzający mogą przekazywać pliki do serwera. Możesz zaznaczyć pole wyboru Dostęp do pliku dziennika zdarzeń (Log access), aby włączyć plik lub katalog do pliku dziennika. Jeśli zaznaczono Przeglądanie katalogu (Directory browsing), odwiedzający mogą zobaczyć zawartość katalogu w celu stwierdzenia, czy nie znajduje się w nim domyślna strona. Zazwyczaj nie będziesz chciał wybrać tej opcji, ponieważ odwiedzający mogą znaleźć stronę na twojej witrynie posługując się łączami zamiast przeglądać listę stron twojej witryny. Jeśli zaznaczysz pole wyboru Indeksuj bieżący katalog (Index this directory), strony w witrynie lub katalogu będą podlegały automatycznego indeksowaniu, co spowoduje stworzenie bazy danych, która pozwoli użytkownikom przeszukać zawartość strony. Reszta właściwości w tej zakładce zostanie omówiona w tym rozdziale nieco później.
Dokumenty Zakładka właściwości Dokumentów (Documents) usługi WWW ukazano na rysunku 2.11.
39
ASP – Kompendium programisty
Rysunek 2.11. Zakładka właściwości dokumentów Kiedy wpisujesz adres sieciowy taki jak http://www.something.com, faktycznie jesteś odsyłany do konkretnej strony na witrynie, przykładowo http://www.something.com/index.html lub http://www.something.com/default.asp. Te strony nazywane są stronami domyślnymi. Jeśli nie określisz strony, do której chcesz się dostać, serwer zakłada, że żądasz dostępu do domyślnej strony w witrynie lub katalogu; na wielu serwerach istnieje taka ustalona nazwa, jak index.html. W serwerze IIS możesz określić nawet kilka nazw stron domyślnych. Robi się to przy użyciu przycisku Dodaj (Add) w zakładce Dokumenty (Documents). Gdy tylko nazwy zostaną określone, możesz ustalić kolejność, w której IIS powinien przeglądać strony domyślne. Na przykład ustalając kolejność taką jak na rysunku 2.11, IIS najpierw odszuka stronę default.htm. Jeśli jej nie znajdzie, w drugiej kolejności postara się odszukać stronę default.asp. Jeśli zaznaczysz pole Udostępnij stopkę dokumentu (Enable document footer) i określisz nazwę strony, IIS wstawi tą stronę na dole każdej innej wywoływanej strony. Mógłbyś użyć tej funkcji do automatycznego dodawania informacji o prawach autorskich do zawartości wszystkich stron bez konieczności ich modyfikacji, określając jedynie w polu stopki dokumentu nazwę strony, w której taka informacja się znajduje.
Błędy klienta Zakładka właściwości Błędów klienta (Customer Errors) pokazana została na rysunku 2.12.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
40
Rysunek 2.12. Zakładka właściwości Błędów klienta Kiedy próbujesz uzyskać dostęp do strony, która nie istnieje, otrzymasz wiadomość, która poinformuje cię o tym fakcie. Większość witryn WWW wyświetla tą wiadomość o błędzie w bardzo surowym formacie, ukazującym jedynie numer błędu i jego opis. Inne witryny natomiast prezentują bogatszą informację o błędzie, która nie daje ci odczuć, że nagle utknąłeś nie posiadając możliwości wyjścia z sytuacji. IIS daje możliwość powrotu do dowolnej, określonej strony, kiedy wystąpi jakiś błąd. Na przykład zamiast prezentować odwiedzającemu sztywną wiadomość, że strona nie została odnaleziona, być może zechcesz dać im możliwość poszukania tej strony na twojej witrynie, lub udostępnisz im kontakt, przez który będą mogli poinformować cię o martwym łączu. Możesz określić nazwę strony, którą chcesz wyświetlać, dokonujesz naciskając przycisk Edytuj właściwości (Edit Properties), podświetlając najpierw ten numer błędu, przy wystąpieniu którego strona ma być wyświetlona.
Witryny WWW w serwerze IIS Jak widać na rysunku 2.13, na serwerze IIS możesz mieć wiele witryn WWW. Witryny na IIS są zaznaczone ikoną, która przedstawia dłoń trzymającą glob ziemski. W poprzednim przykładzie zainstalowanych było siedem witryn WWW: Default Web Site, Administration Web Site, NetStats2000, Travel Science, WindowsNTExpert, NationsInstitute oraz Invitations4Less.
41
ASP – Kompendium programisty
Rysunek 2.13. Witryny WWW w serwerze IIS Zauważ, że następna kolumna po opisie witryny nosi nazwę stanu. Ta kolumna zawiera informacje o tym, czy dana witryna aktualnie jest uruchomiona, spauzowana lub zatrzymana. Witryna uruchomiona jest osiągalna dla obecnych i nowych połączeń; spauzowaną mogą obejrzeć tylko ci, którzy już są połączeni; zatrzymana witryna jest wyłączona i niedostępna dla żadnych połączeń. Aby uruchomić, zatrzymać bądź spauzować witrynę WWW, kliknij prawym przyciskiem myszy witrynę w prawej połowie konsoli MMC, a następnie wybierz Uruchom (Start), Zatrzymaj (Stop) bądź Przerwij (Pause), jak pokazano na rysunku 2.14. Tego samego dokonać można w menu Działanie (Action) lub w pasku narzędziowym, wybierając odpowiednią ikonę.
Rysunek 2.14. Uruchamianie, zatrzymywanie i pauzowanie witryny WWW
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
42
Dodawanie witryny WWW Możesz dodać witrynę WWW do serwera IIS przy użyciu Kreatora nowych witryn WWW. Dostęp do kreatora uzyskuje się klikając prawym przyciskiem myszy ten komputer z listy, na którym chcesz umieścić witrynę, a następnie wybierając pozycję Nowy (New) i Witryna WWW (Web Site), tak jak pokazano na rysunku 2.15.
Rysunek 2.15. Wybór Kreatora nowych witryn WWW Kreator przeprowadzi cię przez proces dodawania nowej strony do serwera IIS. Pierwszym krokiem będzie wpisanie nazwy witryny (Rysunek 2.16). Ta nazwa będzie służyła identyfikacji witryny. W drugim kroku dokonasz konfiguracji adresu IP oraz numeru portu dla tej witryny WWW (Rysunek 2.17).
Rysunek 2.16. Pierwszy krok Kreatora nowych witryn WWW
43
ASP – Kompendium programisty
Rysunek 2.17. Drugi krok Kreatora nowych witryn WWW Po pierwsze należy wybrać adres IP dla twojego serwera. Jeśli serwer posiada pojedynczy adres IP, możesz jego wartość wybrać z listy. Jeśli serwer posiada więcej niż jeden adres IP, będziesz musiał wiedzieć, pod którym z nich zarejestrowana jest twoja nazwa domeny. Jeśli tego nie wiesz, skontaktuj się z twoim dostawcą Internetu bądź administratorem sieci w celu zasięgnięcia takich informacji. Jak się przekonasz później, jedną z najbardziej znaczących zmian dokonanych w IIS wersji 4 jest możliwość umieszczenia wielu witryn WWW pod jednym adresem IP — tak więc rzeczywiście będziesz potrzebował tylko jednego adresu IP. Numery portów powinny być pozostawione bez zmian. Znajdują się tam domyślne wartości, które wysyła przeglądarka. Jeśli wpiszesz inne numery portów, odwiedzający witrynę będą musieli znać te wartości, aby uzyskać do niej dostęp. Jeśli przykładowo nie zmienisz numeru portu TCP, goście mogliby odwiedzać stronę http://www.somewhere.com. Jeśli zmienisz ten numer na 9269, to goście będą musieli dodawać ten numer do adresu. Będzie on wyglądał następująco: http://www.somewhere.com:9269. Zazwyczaj nie dokonuje się zmiany numeru, ponieważ byłoby to kłopotliwe dla twoich gości, którzy rzadko wprowadzaliby ten numer. Jest to jednak technika pozwalająca na zróżnicowanie sposobów dostępu do serwera sieciowego bez konieczności posiadania dodatkowej domeny. W ten sposób można na przykład administrować serwerem IIS zdalnie poprzez sieć WWW. Robi się to przy użyciu zwykłej nazwy domeny uzupełnionej odpowiednim numerem portu. W trzecim kroku kreatora określasz fizyczne położenie plików witryny na twoim serwerze, co pokazano na rysunku 2.18.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
44
Rysunek 2.18. Trzeci krok Kreatora nowych witryn WWW Naciśnij przycisk Przeglądaj (Browse) aby wybrać katalog, który zawiera najwyższy poziom witryny WWW. Wszystkie pliki witryny muszą być umieszczone w tym katalogu i jego podkatalogach, chyba że stworzysz katalog wirtualny, omówiony dalej w tym rozdziale. Katalogiem najwyższego poziomu może być każdy katalog na twoim serwerze. Jeśli zaznaczysz pole Zezwól na dostęp anonimowy (Allow anonymous access), każdy gość będzie mógł dostać się do plików tej witryny; w innym wypadku gość będzie musiał posiadać konieczne uprawnienia dostępu do tego katalogu. Przypis
Możesz modyfikować wartości ustawione podczas pracy kreatora również później, przeglądając właściwości danej witryny.
W ostatnim kroku kreatora dokonujesz wyboru uprawnień dostępu do witryny WWW. (Rysunek 2.19). Jeśli zaznaczysz pole Zezwól na odczyt (Allow Read Access), odwiedzający będą mogli przeglądać zawartość witryny. Kiedy zaznaczysz pole Zezwól na dostęp do skryptu (Allow Script Access), wtedy skrypty takie jak ASP mogą być uruchamiane na tej witrynie. Zauważ jednak, że możesz umieścić twoje skrypty w jednym folderze, a następnie zezwolić na ich uruchamianie jedynie w tym folderze, nie na całej stronie.
45
ASP – Kompendium programisty
Rysunek 2.19. Czwarty krok Kreatora nowych witryn WWW Zaznaczenie pola Zezwól na uruchamianie (Allow Execute Access) umożliwi aktywację plików wykonywalnych poprzez witrynę WWW. To pole nie jest zaznaczane zbyt często, ponieważ możesz nie chcieć, aby twoi goście uruchamiali aplikacje przez Internet. Jeśli zaznaczysz pole Zezwól na zapis (Allow Write Access), odwiedzający będą mogli przekazywać pliki do witryny. Zaznaczenie pola wyboru Zezwól na przeglądanie katalogu (Allow Directory Browsing) umożliwi gościom zobaczenie listy nazw wszystkich plików w każdym z katalogów witryny WWW. Kiedy klikniesz przycisk Zakończ (Finish) strona, którą utworzyłeś, jest dodawana do serwera IIS i powinna być widoczna w oknie konsoli MMC. Zauważ jednak, że po dodaniu witryny jest ona wyłączona. Będziesz musiał ją uaktywnić klikając jej ikonę prawym przyciskiem myszy i wybierając Uruchom (Start). Po tej ostatniej operacji, twoja witryna powinna być już dostępna.
Właściwości witryny WWW Wiele właściwości witryny WWW jest dziedziczonych przez właściwości, które ustawiłeś w usłudze WWW opisanej wcześniej. Jeśli zmodyfikujesz je na poziomie witryny, wtedy właściwości witryny zastąpią właściwości dziedziczone. W tym podrozdziale dokonamy przeglądu niektórych właściwości witryn WWW, a część nie podanych tutaj informacji znajdziesz nieco wcześniej.
Wiele witryn pod jednym adresem IP Nową funkcją serwera IIS wersji 4.0 jest zdolność odwzorowywania więcej niż jednej witryny od jednym adresem IP. Aby to zrealizować, należy wykonać czynności przedstawione poniżej dla wszystkich witryn umiejscowionych pod jednym adresem IP. Kliknij prawym przyciskiem myszy witrynę w oknie konsoli MMC i wybierz Właściwości (Properties). Wybierz zakładkę Witryna WWW (Web Site), a wtedy pokaże się odpowiedni arkusz przedstawiony na rysunku 2.20.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
Rysunek 2.20. Właściwości witryny WWW Teraz naciśnij przycisk Zaawansowane (Advanced). Zobaczysz okno dialogowe, takie jak na rysunku 2.21. Zauważ, że zapis znajdujący się pod hasłem Wielorakie tożsamości dla witryny WWW (Multiple identities for this Web Site) wyszczególnia adres IP oraz numer portu, nie zawiera natomiast Nazwy nagłówka komputera macierzystego (Host Header Name), która jest nazwą domeny tej witryny. W to pole musimy wpisać odpowiednią wartość. Naciśnij Przycisk Edytuj (Edit) w celu wyświetlenia tego zapisu, a wtedy zobaczysz kolejne okno dialogowe pokazane na rysunku 2.22.
46
47
ASP – Kompendium programisty
Rysunek 2.21. Zaawansowane właściwości witryny WWW
Rysunek 2.22. Okno dialogowe zaawansowanej identyfikacji witryny WWW Wprowadź nazwę domeny w pole tekstowe Nazwy nagłówka komputera macierzystego (Host Header Name) i naciśnij OK. Teraz kiedy serwer IIS otrzyma żądanie dostępu do tej domeny, skieruje żądanie do właściwej witryny, pomimo że wiele witryn WWW jest umieszczonych pod jednym adresem IP.
Zakładka właściwości witryny WWW Zwróć uwagę na inne właściwości przedstawione w oknie na rysunku 2.20. Możesz zmodyfikować nazwę witryny WWW, której używasz do jej identyfikacji.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
48
Możesz również określić maksymalną liczbę połączeń z witryną w danym czasie. Jest to użyteczne w scenariuszu wielorakich domen, w którym możesz pobierać opłaty za umieszczenie witryny WWW na podstawie maksymalnej ilości dopuszczalnych połączeń. Możesz również wybrać sposób rejestrowania żądań witryny. Pamiętaj o tym, że domyślnie ustawiana jest tutaj ta wartość, którą wprowadziłeś we właściwościach usługi WWW.
Właściwości katalogu macierzystego Teraz wybierz zakładkę Katalog macierzysty (Home Directory), jak to pokazano na rysunku 2.23. Pierwszym ustawieniem, jakiego możesz dokonać tutaj, jest położenie plików danej witryny. Zależnie od tego, na co się zdecydujesz, tak zmieni się część zakładki poniżej.
Rysunek 2.23. Właściwości katalogu macierzystego Jeśli zdecydujesz się na umieszczenie witryny na tym komputerze, na którym aktualnie pracujesz, będziesz mógł wybrać lokalną ścieżkę oraz dowolną z poniżej wyszczególnionych właściwości. Jeśli wybierzesz katalog współdzielony, zostaniesz zapytany o podanie nazwy serwera oraz folderu współdzielonego w postaci \\[serwer]\[udział]. Możesz również wybrać readresowanie (redirection), co spowoduje, że podczas próby dostępu odwiedzającego do twojej witryny, zostanie on odesłany do jakiegoś innego miejsca w Internecie. Kiedy zdecydujesz się na tą opcję, zostaniesz poproszony o podanie adresu URL, do którego nastąpi przekierowanie. Nie możesz wtedy jednak ustawić innych właściwości w tej zakładce. Ustawienia aplikacji (Applications Settings) zostały omówione w podrozdziale „Właściwości aplikacji” w dalszej części tego rozdziału.
Eksploracja witryny Teraz, kiedy już dodałeś i skonfigurowałeś witrynę WWW, możesz przeglądać zawartość strony w podobny sposób, jak robi się to przy użyciu Eksploratora Windows. Możesz rozwijać listę katalogów, jak to pokazano na rysunku 2.24.
49
ASP – Kompendium programisty
Rysunek 2.24. Eksploracja witryny WWW
Katalogi wirtualne Możesz przejrzeć zawartość każdego folderu twojej witryny. Te pliki i foldery odpowiadają plikom i folderom logicznym, które znajdują się w strukturze katalogu macierzystego tej witryny. Możesz również stworzyć katalogi wirtualne. Katalogi wirtualne są folderami, które znajdują się poza fizyczną strukturą katalogów witryny WWW, ale chcesz je włączyć do witryny. Przypuśćmy na przykład, że masz witrynę zawierającą podkatalogi html i script. Adresujesz te katalogi poprzez określenie nazwy domeny, po której następuje nazwa odpowiedniego podkatalogu: http://www.somewhere.com/html/welcome.html. Posiadasz jednak na serwerze inny katalog zawierający pliki video, które chcesz udostępnić poprzez witrynę WWW w katalogu o nazwie avi. W bieżącej konfiguracji pliki te nie są dostępne dla twojej witryny, ponieważ znajdują się poza jej fizyczną strukturą katalogów. Możesz jednak stworzyć katalog wirtualny wskazujący katalog avi, który w ten sposób zostanie włączony w logiczną strukturę twojej witryny. Aby stworzyć katalog wirtualny, kliknij prawym przyciskiem myszy ikonę witryny bądź folderu, gdzie katalog wirtualny ma być dodany i wybierz Nowy (New), a następnie Katalog wirtualny (Virtual Directory), jak to pokazano na rysunku 2.25. W ten sposób uruchomisz Kreatora nowego katalogu wirtualnego (New Virtual Directory Wizard). Jego pierwsze okno prezentuje rysunek 2.26.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
50
Rysunek 2.25. Dodawanie katalogu wirtualnego
Rysunek 2.26. Kreator nowego katalogu wirtualnego — krok pierwszy Pierwszą rzeczą, jaką należy wprowadzić jest nazwa dla katalogu wirtualnego, która będzie widoczna na twojej witrynie WWW. Innymi słowy, jeśli katalog fizyczny nosi nazwę PublicVideos, ale ty chcesz aby nazwa ta podczas dostępu do strony brzmiała Videos, taką właśnie nazwę wpiszesz w polu tekstowym pierwszego okna kreatora. W drugim kroku kreatora określisz fizyczne położenie katalogu wirtualnego (Rysunek 2.27). Naciśnij przycisk Przeglądaj (Browse) i ustal lokalizację katalogu fizycznego.
51
ASP – Kompendium programisty
Rysunek 2.27. Kreator nowego katalogu wirtualnego — krok drugi W kroku trzecim (Rysunek 2.28) możesz określić uprawnienia dostępu do katalogu wirtualnego. Następnie naciśnij przycisk Zakończ (Finish). Od tej pory nowy katalog wirtualny, fizycznie umiejscowiony poza twoją witryną, staje się dostępny dla odwiedzających.
Rysunek 2.28. Kreator nowego katalogu wirtualnego — krok trzeci
Właściwości folderu i pliku Dowiedziałeś się już, w jaki sposób ustawiać właściwości dla samej usługi WWW. Wiesz również, jak to samo zrobić z poszczególnymi witrynami, których właściwości są dziedziczone z usługi WWW. Teraz dowiemy się jak ustawiać właściwości konkretnych folderów i plików witryny. Dostęp do właściwości uzyskuje się klikając
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
52
dany folder prawym przyciskiem i wybierając Właściwości (Properties). Powinieneś wtedy ujrzeć okno dialogowe pokazane na rysunku 2.29.
Rysunek 2.29. Właściwości folderu Właściwości folderu są dziedziczone przez właściwości witryny WWW, dlatego zwykle nie trzeba ich ustawiać. Dzięki nim jednak masz możliwość precyzyjnej konfiguracji twojej witryny. Możesz na przykład przeznaczyć jeden folder na przechowywanie skryptów. W takim wypadku ustalisz dla niego uprawnienia skryptu. Jeśli chcesz rejestrować dostęp do pojedynczego folderu, zrobisz to poprzez Właściwości folderu. Każdy plik folderu również posiada swoje właściwości. Są one pokazane na rysunku 2.30. Właściwości pliku są dziedziczone z właściwości folderu, tak więc hierarchia dziedziczenia przedstawia się następująco: usługa WWW, witryna WWW, folder, a na końcu plik.
Aplikacje ASP Zmienne trwałe i zakresowe Aplikacja ASP to wymyślna nazwa, która określa po prostu grupę stron ASP ulokowanych w jednej strukturze katalogu, z którymi pracować możesz podobnie jak z aplikacją. Sama strona ASP jest jednostką oddzielną, podobną do wyspy, która nie dzieli się informacjami zapamiętanymi w zmiennych z innymi stronami ASP. Strona będąca częścią aplikacji ASP może współużytkować i przetrzymywać zmienne trwałe poza pojedynczą stroną oraz zapamiętywać dane zakresowe poza nią. Przez zmienne trwałe rozumiemy takie zmienne, które pozostają dostępne po wyłączeniu strony. Zmienne zakresowe to takie zmienne, które są widoczne również poza tą stroną, która z nich korzysta. Tak więc przy użyciu aplikacji ASP możesz stworzyć zmienne, które będą istniały po opuszczeniu strony przez odwiedzającego oraz zmienne widoczne dla innych stron aplikacji. Załóżmy, że masz dobrze zabezpieczoną stronę i chcesz, aby odwiedzający logowali się na witrynie, zanim będą mogli zobaczyć którąkolwiek ze stron. Mają logować się na pojedynczej stronie, a ty musisz być powiadomiony przez inne strony o fakcie logowania. Zrealizujesz to przy użyciu aplikacji ASP, ponieważ
53
ASP – Kompendium programisty
możesz w niej stworzyć zmienną UserID zapamiętującą numer identyfikacyjny użytkownika. Jeśli numer znajdzie się w zmiennej, będziesz wiedział jaki użytkownik logował się na witrynie. W rozdziale pierwszym przyjrzeliśmy się stronie quizu. Strona pozwalała gościom odpowiadać na kolejne pytania, a my otrzymywaliśmy ich wyniki. Było to realizowane przez pojedynczą stronę. Jeśli chcielibyśmy rozwinąć to narzędzie, potrzebowalibyśmy dodatkowych stron w celu ewentualnego formatowania pytania. Być może pozwolilibyśmy przeglądać odpowiedzi na innej stronie. Strony musiałyby wtedy przekazywać sobie informacje dotyczące testu, jego wyników itd. Aby to osiągnąć, potrzebujemy aplikacji ASP. Może chcesz stworzyć program usługowy, który pozwalałby na śledzenie poczynań odwiedzającego witrynę, jego przejścia pomiędzy stronami. Będziesz wtedy musiał w jakiś sposób identyfikować danego odwiedzającego, aby odpowiedni zapis umieścić w jakiejś tabeli wykorzystania witryny. Taka zmienna identyfikacji, która mogłaby się nazywać ConnectionID, byłaby przekazywana pomiędzy stronami. Aplikacja ASP pozwoli na realizację tego typu zadania.
Zdarzenia Zdarzeniami nazywa się kody, które stanowią odpowiedź na podejmowane na stronie działania. Na przykład, w Visual Basic kliknięciu przycisku odpowiada zdarzenie Click; kiedy użytkownik nie wypełni pola tekstowego, uruchamiane jest zdarzenie Lost Focus. Konkretne działanie użytkownika pociąga za sobą wystąpienie zdarzenia. Możesz napisać kod, który zostanie uruchomiony po wywołaniu zdarzenia. Kiedy odwiedzający kliknie przycisk, być może zamknie się formularz lub kiedy zostawi puste pole tekstowe, możliwe, że wtedy zostanie uruchomiony kod zatwierdzający jego wejście. Jak się dowiemy szerzej z rozdziału ósmego przy okazji omawiania pliku global.asa, używając aplikacji ASP dysponujesz czterema zdarzeniami, po wystąpieniu których możesz uruchomić napisany przez siebie kod. Możesz napisać kod dla zdarzenia Application_OnStart. Kod tej procedury działa za każdym razem, kiedy twoja aplikacja ASP jest uruchamiana. Uruchomienie aplikacji następuje w chwili, kiedy pierwszy odwiedzający uzyskuje dostęp do strony ASP. Możesz stworzyć kod dla zdarzenia Session_OnStart. To zdarzenie działa, kiedy odwiedzający przegląda pierwszą stronę ASP. Różni się ono tym od Application_OnStart, że jest uruchamiane dla wszystkich gości strony, a nie jedynie dla pierwszego z nich. Kolejnym zdarzeniem jest Session_OnEnd. Uruchamiane jest w chwili, gdy połączenie odwiedzającego z twoją witryną kończy się. Zdarza się to szczególnie wtedy, gdy czas sesji odwiedzającego upływa lub kiedy ustawiłeś koniec sesji programowo. Ostatnim zdarzeniem dostępnym w aplikacji ASP to zdarzenie Application_OnEnd. Kod procedury uruchamiany jest w chwili, kiedy praca witryny WWW, której część stanowi aplikacja ASP, zostaje zatrzymana.
Tworzenie aplikacji ASP Teraz, kiedy już wiesz po co tworzy się aplikacje ASP, przyjrzyjmy się jak zrealizować to zadanie przy użyciu serwera IIS. Jak wspomniano wcześniej, aplikacje ASP składają się z katalogów oraz wszystkich znajdujących się w nich podkatalogów. Katalog może być częścią jednej tylko aplikacji ASP, tak więc jeśli katalog główny jest składnikiem innej aplikacji, a ty tworzysz nową aplikację przy użyciu tego katalogu, staje się on jej częścią. Używając konsoli MMC, kliknij prawym przyciskiem myszy katalog zawierający pliki, które mają stanowić aplikację ASP i wybierz Właściwości (Properties). Upewnij się, czy poruszasz się po zakładce Katalogi (Directories), powinna ona wyglądać tak jak ta na rysunku 2.31.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
54
Rysunek 2.31. Właściwości katalogu Obszarem, który będziemy wykorzystywać znajduje się w dolnej części okna pod nazwą Ustawienia aplikacji (Application Settings). Kliknij przycisk Utwórz (Create), a wtedy uaktywnione zostanie pole nazwy aplikacji (Rysunek 2.32).
Rysunek 2.32. Okno właściwości katalogu z uaktywnionym polem nazwy
55
ASP – Kompendium programisty
Wpisz nazwę twojej aplikacji ASP w polu tekstowym Nazwa (Name). Podana nazwa będzie służyła twojej własnej identyfikacji. Po naciśnięciu OK aplikacja ASP zostaje stworzona. Zauważ, że ikona katalogu zmieniła się z folderu na pole z małym, zielonym iksem w środku. Aby usunąć aplikację ASP, po prostu wróć do właściwości katalogu i naciśnij przycisk Usuń (Remove).
Konfigurowanie aplikacji ASP Zwróć uwagę na pole wyboru Uruchom w osobnej przestrzeni pamięci (proces izolowany) (Run in separate memory space (isolated process)). Jeśli jest ono zaznaczone, twoja aplikacja ASP będzie działała poza serwerem IIS. Kiedy więc twoja aplikacja spowoduje jakiś poważny problem i będzie musiała być zamknięta, nie spowoduje to zawieszenia działania innych aplikacji czy samego serwera IIS. Negatywnym aspektem zaznaczenia tego pola jest konieczność wykorzystania dodatkowych zasobów. Aby przejrzeć inne opcje konfiguracyjne dla aplikacji, kliknij przycisk Konfiguracja (Configuration) znajdujący się we właściwościach katalogu, a wtedy zobaczysz okno dialogowe, które prezentuje rysunek 2.33.
Rysunek 2.33. Odwzorowania aplikacji Pierwsza zakładka zawiera Odwzorowania aplikacji (App Mappings). Te odwzorowania informują IIS o tym, jakie programy wspierające uruchomić, kiedy strona o określonym rozszerzeniu zostaje wywoływana. Kliknij na przykład rozszerzenie .asp znajdujące się na liście i wybierz Edytuj (Edit). Powinieneś wtedy ujrzeć okno ustawień pokazane na rysunku 2.34.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
56
Rysunek 2.34. Odwzorowanie rozszerzenia aplikacji Pierwsze pole okna zawiera nazwę programu, który będzie przetwarzał stronę. W drugim polu znajduje się rozszerzenie, które musi mieć strona, aby mogła zostać przetworzona przez określony program wykonywalny. W trzecim polu możesz wpisać dowolną metodę HTTP, której nie chcesz uruchamiać wraz z programem wykonywalnym. Dla ASP będziesz mógł zaznaczyć w polu wyboru, że jest to moduł skryptu. Pole wyboru Sprawdź czy plik istnieje (Check that file exist) nie jest potrzebna przy ASP. Przypis
Jeśli kiedykolwiek znajdziesz się w takiej sytuacji, że podczas próby wyświetlenia strony ASP ujrzysz jedynie sam kod ASP, prawdopodobnie brak jest odpowiedniego zapisu w oknie pokazanym na rysunku 2.34. Musisz go dodać do twoich Odwzorowań aplikacji.
Przejdź teraz do drugiej zakładki okna — Opcji aplikacji (App Options), pokazanego na rysunku 2.35.
Rysunek 2.35. Opcje aplikacji
57
ASP – Kompendium programisty
Pierwszą rzeczą, jaką możesz zrobić w tej zakładce to uaktywnienie stanu sesji. Jak wspomniano we wcześniejszym podrozdziale, pojęcie stanu odnosi się do możliwości zapamiętywania zmiennych, które są widoczne dla wszystkich stron poza bieżącą stroną aplikacji. Aby na to zezwolić, musisz uaktywnić stan sesji. Wtedy będziesz mógł ustalić czas trwania sesji. Ta wartość przedstawia w minutach czas, po upłynięciu którego sesja odwiedzającego uważana jest za zakończoną. Jeśli wartość ta będzie wynosić 20 minut, to przed upływem tego czasu odwiedzający będzie musiał przejść do następnej strony. W przeciwnym razie wszystkie informacje sesji zostaną utracone. Jeśli zaznaczono pole Uaktywnij buforowanie (Enable buffering), strona ASP będzie musiała zakończyć całe przetwarzanie przed wysłaniem wyniku w postaci HTML do przeglądarki. Zaznaczenie pola wyboru Uaktywnij ścieżki nadrzędne (Enable parent paths) pozwala na adresowanie względne katalogu nadrzędnego. Pole Domyślnego języka ASP (Default ASP language) określa skrypt, z którego korzysta twoja strona ASP. Pole Czas trwania skryptu ASP (ASP Script timeout) zapamiętuje czas w sekundach, w którym strona musi wykonać cały swój kod, inaczej nastąpi jej wyłączenie. Może tak się zdarzyć z wielu powodów: serwer może być zbyt zajęty, ilość danych zwracanych jest zbyt duża lub kod natrafił na nie kończącą się pętlę. Trzecia zakładka zawiera opcje usuwania błędów (Rysunek 2.36).
Rysunek 2.36. Opcje usuwania błędów aplikacji ASP Jeśli zaznaczysz opcję Usuwanie błędów skryptu po stronie serwera (Server-Side Script Debugging), możesz ustawić punkty kontrolne dla twojego kodu i zatrzymać jego wykonywanie, a wtedy debugger przystąpi do jego analizy. Usuwanie błędów zostało omówione szerzej w rozdziale 12. Opcja Usuwanie błędów skryptu po stronie klienta (Client-Side Script Debugging) nie ma w tej chwili znaczenia. Późniejsze wersje serwera IIS mogą korzystać z tej opcji. Kiedy w twoim kodzie pojawi się błąd, przeglądarce wysyłana jest wiadomość. Może ona zawierać dokładne informacje obejmujące numer błędu, opis oraz linię kodu, w której wystąpił. Aby skorzystać z tej funkcji, zaznacz pole Szczegółowa wiadomość o błędzie (Detailed error message). Drugą możliwością jest tutaj wyświetlenie ogólnej wiadomości tekstowej.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
58
Witryny FTP Oprócz witryn WWW, na serwerze IIS mogą również znajdować się witryny FTP, które umożliwiają łatwe pobieranie i przekazywanie plików serwera. Domyślna witryna FTP jest instalowana wraz z serwerem IIS. Aby zainstalować nową witrynę FTP kliknij prawym przyciskiem myszy ikonę komputera, na którym ma się ona znaleźć, a następnie wybierz Nowy (New) i Witryna FTP (FTP Site). Konfiguracji nowej witryny FTP dokonuje się poprzez okno Właściwości (Properties), które pojawi się, kiedy klikniesz ikonę witryny prawym przyciskiem myszy. Wygląd okna prezentuje rysunek 2.37.
Rysunek 2.37. Właściwości witryny FTP Zauważ, że podobnie jak to było w wypadku właściwości usługi WWW, również właściwości usługi FTP są dziedziczone przez witryny FTP. W tej pierwszej zakładce ustalasz informacje służące identyfikacji witryny. Możesz ustalić również maksymalną liczbę połączeń, a także czas rozłączenia. Czas rozłączenia (Timeout) określa w sekundach, kiedy nastąpi rozłączenie użytkownika, który pozostaje nieaktywny. Tak jak w wypadku witryn WWW, możesz monitorować korzystanie z witryny FTP. Jeśli klikniesz przycisk Bieżące sesje (Current Sessions), ujrzysz listę aktualnych użytkowników witryny. W zakładce Konta bezpieczeństwa (Security Accounts), pokazanej na rysunku 2.38 określisz, kto będzie mógł uzyskiwać dostęp do witryny FTP.
59
ASP – Kompendium programisty
Rysunek 2.38. Konta bezpieczeństwa FTP Jeśli wybierzesz Dostęp anonimowy (Anonymous Access), każdy będzie mógł korzystać z twojej witryny FTP. Prawdopodobnie zezwolisz na dostęp do witryny jedynie niektórym odwiedzającym. Możesz to zrobić w dolnej części zakładki. Inne właściwości witryny FTP pozwalają na określenie powitania i pożegnania, które będą widoczne dla odwiedzających witrynę. Możesz również określić nazwę fizycznego katalogu, który będzie pełnił rolę punktu wejścia. Ponadto możesz odrzucić bądź zaakceptować niektóre adresy IP.
Rozdział 3. Narzędzia pracy Przegląd aplikacji do tworzenia stron W tym rozdziale przyjrzymy się narzędziom, z których możesz skorzystać podczas tworzenia witryn WWW, kodu HTML, formularzy, a w szczególności stron ASP. Nasze rozważania rozpoczniemy od omówienia najbardziej podstawowego narzędzia, które powinieneś już posiadać, Notatnika. Przekonasz się, że przy użyciu jedynie Notatnika możesz stworzyć swoją własną stronę ASP. Następnie zwrócimy uwagę na parę innych narzędzi, których możesz użyć do tworzenia stron WWW. Te narzędzia, FrontPage 2000 i NetObjects Fusion, posiadają szybki i intuicyjny interfejs do budowania witryn i stron. Przyjrzymy się również dodawaniu elementów do stron przy użyciu tych narzędzi oraz tworzeniu formularzy. Potem skupimy się na narzędziach używanych do tworzenia kodu stron ASP, a na samym początku będzie to NetObjects ScriptBuilder 3.0. To narzędzie tworzenia zawiera wspaniały interfejs, który powoduje, że tworzenie bloków kodu jest niesamowicie proste. Przyjrzymy się również Visual InterDev Microsoftu. Jeśli jesteś zaznajomiony z jakimkolwiek produktem serii Visual Studio, przyjemnie zaskoczy cię jego podobny układ i funkcjonalność.
Notatnik Jeśli masz komputer z zainstalowanym systemem Windows jakiejkolwiek wersji, to już posiadasz narzędzie do tworzenia stron ASP i pracy z nimi — to narzędzie to Notatnik. Strony WWW i ASP są stworzone po prostu przy użyciu tekstu, dlatego jedyną rzeczą, której potrzeba do ich tworzenia i pracy z nimi jest edytor tekstu. Notatnik lub jakikolwiek inny edytor tekstu, świetnie będzie wspomagał tworzenie i edycję stron HTML i ASP. Naprawdę, czasami to wszystko czego potrzebujesz. Osobiście posiadam duży wybór narzędzi do tworzenia stron WWW, witryn oraz stron ASP, ale w dalszym ciągu od czasu do czasu używam Notatnika. Jednym z powodów jest tutaj prostota ładowania tego edytora tekstu przy jego olbrzymich możliwościach twórczych. Kolejnym powodem do rozważenia możliwości użycia edytora tekstu jest fakt, że jest on dostępny nawet na mniej zaawansowanych technologicznie komputerach. Zawsze powinieneś znaleźć na nich edytor tekstu, a jeśli istnieje możliwość połączenia z twoim serwerem internetowym, na bieżąco możesz dokonywać modyfikacji stron. Ponadto w przypadku prostego HTML, to bardzo ważne, aby okresowo przeglądać swój naturalny kod. Przekonasz się, że wiele narzędzi używanych do tworzenia stron i witryn WWW dodaje liczne linie kodu układu tabeli, które mogą być swobodnie usunięte co spowoduje, że twoja strona stanie się dużo mniejsza i będzie się ładowała dużo szybciej. Spójrzmy na przykład poniższego kodu HTML, który został wygenerowany przez narzędzie tworzenia witryn, zwane NetObjects Fusion, które omówimy później:
| | | | | | | |
| All invitations and accessories priced at a 25% discount! | |
|
Prawie identyczne wyjście można uzyskać z następującego kodu HTML:
All invitations and accessories priced at a 25% discount!
Ten kod jest objętościowo jedynie ułamkiem tego poprzedniego, tak więc strona będzie wyświetlana znacznie szybciej. Jedyną rzeczą, o której należy pamiętać używając Notatnika jako edytora stron ASP jest nadanie plikowi odpowiedniego rozszerzenia. Notatnik domyślnie przydziela rozszerzenie .txt. Kiedy więc zapisujesz plik napisany w Notatniku, upewnij się, czy przydzieliłeś mu właściwe rozszerzenie, jak to pokazano na rysunku 3.1.
Rozdział 3 – Narzędzia pracy
62
Rysunek 3.1. Przydzielanie właściwego rozszerzenia w Notatniku
FrontPage 2000 FrontPage 2000 jest narzędziem Microsoftu, które możesz wykorzystać do tworzenia pojedynczych stron i witryn WWW. Ponieważ FrontPage jest produktem Microsoftu, jest zaprojektowany tak, aby współpracował z serwerem IIS, umożliwiając natychmiastową modyfikację witryny WWW; używając innych narzędzi musisz w zasadzie załadować stronę na serwer.
Środowisko pracy Rysunek 3.2 pokazuje środowisko, w którym strona WWW jest przeglądana. Widok pokazany na tym rysunku jest widokiem strony, którą przejrzeć można naciskając przycisk Strona (Page) w pasku narzędziowym znajdującym się po lewej stronie ekranu. Kiedy przycisk zostanie naciśnięty, w środku okna ukaże się panel prezentujący zawartość bieżącego folderu. W tym przypadku katalog macierzysty FrontPage nazywa się fpsample.
63
ASP – Kompendium programisty
Rysunek 3.2. Środowisko pracy FrontPage w czasie przeglądania strony WWW W prawym panelu okna FrontPage prezentowana jest zawartość aktualnie wybranej strony WWW. Klikając dowolną stronę w panelu środkowym, uaktywniamy ją w prawym panelu. W prawym panelu dostępne są trzy rodzaje widoków strony. Pierwszy z nich, pokazany na rysunku 3.2, to widok normalny, gdzie możliwe jest graficzne dodawanie i edycja elementów strony. Jeśli zmienisz widok na HTML, ujrzysz sam kod HTML (Rysunek 3.3.). W widoku normalnym możesz edytować kod HTML, aby dodać skrypty lub kod ASP. Możesz go użyć również jako narzędzia szkoleniowego, pokazującego co dzieje się ze stroną, gdy dodajesz do niej różne elementy.
Rysunek 3.3. Widok HTML strony WWW w programie FrontPage
Rozdział 3 – Narzędzia pracy
64
Trzecim widokiem jest podgląd. Dzięki temu widokowi pokazanemu na rysunku 3.3 sprawdzisz, jak strona będzie wyglądała w przeglądarce. Ta prosta opcja pozwala na szybki podgląd wyjściowej postaci strony.
Rysunek 3.4. Podgląd strony Przypis
Podgląd jest uruchamiany po stronie klienta. Oznacza to, że każdy kod po stronie klienta również będzie widoczny, ale żadna z twoich stron ASP nie zostanie przetworzona.
Kolejnym widokiem głównym (dostępnym w lewym panelu okna) jest widok Foldery (Folders), co pokazano na rysunku 3.5. Widok ten pozwala na zarządzanie plikami i folderami twojej witryny. Ze środkowego panelu korzystasz w celu wyszukiwania katalogów. W tym samym czasie panel prawy pokazuje zawartość wybranego folderu. Rozszerzona informacja o każdym z nich zawierająca nazwę, tytuł, datę modyfikacji oraz komentarze, jest prezentowana w prawym panelu. Tak więc korzystając z tego widoku w prosty sposób możesz zlokalizować pliki, dodawać do nich zadania, przeglądać ich strukturę oraz sortować je po którymkolwiek z pól.
65
ASP – Kompendium programisty
Rysunek 3.5. Widok Foldery w programie FrontPage Aby dodać komentarz do pliku, kliknij jego ikonę prawym przyciskiem myszy i wybierz Właściwości (Properties). Następnie kliknij zakładkę Skrót (Summary) i wpisz swój komentarz (Rysunek 3.6.). Komentarz możesz dodać do każdego pliku witryny.
Rysunek 3.6. Okno dialogowe wykorzystywane w celu dodawania komentarza do pliku Kolejny widok — Raporty (Reports) — pozwala na przejrzenie rozmaitych raportów dotyczących twojej witryny WWW. Krótki raport domyślny jest pokazany na rysunku 3.7.
Rozdział 3 – Narzędzia pracy
66
Rysunek 3.7. Widok Raporty Przeglądu dodatkowych raportów możesz dokonać wybierając Raporty (Reports) z menu Widok (View). Dzięki temu wygenerujesz listę wolnych stron, starych plików, dodanych ostatnio plików, przerwanych łącz i wielu innych. Niektóre z tych raportów można nawet skonfigurować wybierając Narzędzia (Tools), Opcje (Options), a następnie przeglądając zakładkę Widok raportów (Reports View). Tutaj możesz określić, ile maksymalnie dni ma mieć plik, aby był zakwalifikowany jako nowy. Tak samo zakwalifikować możesz plik jako stary, ustalając minimalną liczbę dni. Możesz również ustalić liczbę sekund, która musi upłynąć podczas ładowania strony, aby uznać ją za wolną. Następnym widokiem, pokazanym na rysunku 3.8, jest Nawigacja (Navigation). Ten widok pozwala na projektowanie logicznego układu witryny. Tutaj możesz dodawać strony do schematu poprzez przeciągnięcie ich z listy folderów do prawego panelu. Tam strony mogą zostać połączone w układ logiczny. W widoku nawigacji możesz usunąć dowolną stronę z witryny bez obawy o to, że plik zostanie usunięty z sieci.
67
ASP – Kompendium programisty
Rysunek 3.8. Widok Nawigacji w programie FrontPage 2000 Przycisk Hiperłącza (Hyperlinks) uruchamia kolejny graficzny widok twojej witryny WWW. Wybierając daną stronę z listy folderów, w prawym panelu ujrzysz jej wszystkie łącza. Ostatnim z widoków są Zadania (Tasks), co pokazano na rysunku 3.9. Prezentuje on działania, które należy podjąć podczas tworzenia witryny WWW. Zadania przydzielane są osobom — mają swój priorytet, status, datę i opis.
Rysunek 3.9. Widok Zadań w programie FrontPage 2000 Możesz mieć przydzielone zadanie ogólne, nie odnoszące się do żadnego szczególnego zadania z listy. Na przykład możesz przydzielić zadanie rejestracji witryny w wyszukiwarce; być może zadaniem będzie ukończenie schematu strony. Aby dodać zadanie ogólne, najpierw upewnij się, czy znajdujesz się w widoku
Rozdział 3 – Narzędzia pracy
68
zadań. Następnie wybierz z menu Edycja (Edit) Zadania (Tasks) i Dodaj zadanie (Add Task). Powinieneś zobaczyć okno pokazane na rysunku 3.10.
Rysunek 3.10. Dodawanie zadania w oknie dialogowym Nowe zadanie W oknie dialogowym Nowe zadanie (New Task) przydzielasz zadanie określonej osobie. Możesz również ustalić priorytet zadania oraz podać jego opis. Kiedy naciśniesz przycisk OK, nowe zadanie zostanie dodane do listy w widoku Zadania. Możesz również przydzielić zadania plikom i folderom w witrynie WWW. Robi się to poprzez wybranie strony z listy folderów, a następnie kliknięcie jej prawym przyciskiem myszy oraz wybranie pozycji Dodaj zadanie (Add Task). Kolejne kroki są takie same jak przy dodawaniu zadania ogólnego. Widok Zadania jest wykorzystywany do zarządzania. Kiedy klikniesz dowolne zadanie prawym przyciskiem, możesz wybrać Rozpocznij zadanie (Start Task), co spowoduje, że przeniesiesz się do pliku związanego z tym zadaniem. Możesz również oznaczyć zadanie jako zakończone klikając je prawym przyciskiem. Zadanie zakończone ma inną ikonę, co ułatwia jego rozpoznanie spośród zadań niezakończonych.
Tworzenie sieci Web W programie FrontPage termin sieć Web odnosi się do nazwy domeny lub podkatalogu, gdzie witryna WWW będzie umieszczona. FrontPage dysponuje kreatorem, którego możesz użyć do stworzenia nowej sieci Web. Aby skorzystać z kreatora wybierz menu Plik (File), Nowa (New), a następnie Sieć Web (Web). Powinieneś ujrzeć dialog wyboru witryn, pokazany na rysunku 3.11.
69
ASP – Kompendium programisty
Rysunek 3.11. Dialog wyboru witryn Bez względu na typ witryny, którą wybierzesz, będziesz musiał podać jej położenie. Jeśli serwer jest oddalony, możesz być zapytany o nazwę użytkownika oraz hasło komputera NT, na którym zainstalowany został serwer IIS. W tym miejscu będzie stworzona twoja witryna. Jeśli pracujesz z witryną i zapisujesz na bieżąco zmiany, będą one natychmiastowo przenoszone na serwer. Zwróć uwagę na duży wybór sieci Web. Jeśli wybierzesz pojedynczą stronę, kreator stworzy ją w jednym tylko w jednym kroku, a niezbędne pliki zostaną umieszczone na serwerze. Inne kreatory są nieco bardziej złożone. Weźmy na przykład kreatora prezentacji firmy. Na samym początku wybierasz strony, które chcesz włączyć do witryny (zobacz rysunek 3.12.).
Rysunek 3.12. Wybór stron witryny prezentującej firmę Dla każdej strony wybierasz elementy, które mają się na niej pojawić. Zaraz po tym, jak kreator wygeneruje stronę, twój wybór zostanie uwzględniony w szablonie strony, który posiada wolne miejsce na dodatkową zawartość. Kreator zapyta cię również o wybór tematu, będącego ogólnym wyglądem twojej witryny, zawierającego kombinację banerów, tła, stylu czcionki i innych elementów. FrontPage zawiera mnóstwo tematów. Możesz je
Rozdział 3 – Narzędzia pracy
70
wybierać bądź zmieniać korzystając z menu Format, a następnie zaznaczając Temat (Theme). Zobaczysz wtedy okno dialogowe pokazane na rysunku 3.13.
Rysunek 3.13. Wybór tematu dla witryny Temat możesz zastosować do dowolnej ilości stron twojej witryny. Możesz również modyfikować wygląd tematu. Staraj się jednak uważnie korzystać z tych gotowych tematów. Pamiętaj, że FrontPage jest bardzo popularny i każdy twórca korzystający z niego posiada te same tematy, co ty. Tak więc ktoś, kto odwiedza twoją witrynę, a wcześniej przeglądał inne stworzone przy użyciu FrontPage, może stwierdzić, że twoja witryna nie jest niczym wyjątkowym.
Przeglądanie strony Jak mogliśmy się zorientować z wcześniejszych kart tego rozdziału, najprostszą i najszybszą metodą przeglądania strony, nad którą pracujesz to wybrać Podgląd (Preview) w trybie Strona (Page) — pozwala to jednak tylko na szybki przegląd. Ty natomiast chciałbyś może zobaczyć, jak twoja strona będzie widziana przez wolnostojącą przeglądarkę. Da się to zrobić wybierając w menu Plik (File) opcję Widok w przeglądarce (Preview in Browser). Wyświetlone zostaje okno dialogowe pokazane na rysunku 3.14.
Rysunek 3.14. Okno dialogowe Widok w przeglądarce To narzędzie podglądu pozwala na wybranie typu przeglądarki, za pomocą której chcesz przeglądać witrynę. To bardzo ważne, aby zobaczyć jak wygląda witryna we wszystkich tych przeglądarkach, których mogą
71
ASP – Kompendium programisty
używać potencjalni użytkownicy, ponieważ czasami strona różnie zachowuje się w różnych typach przeglądarek. Możesz również uzupełnić listę dodatkowymi przeglądarkami klikając przycisk Dodaj (Add). Wpisujesz wtedy nazwę nowej przeglądarki, która pojawi się następnie na liście. Zauważ również, że można dokonać wyboru rozmiaru okna. Pamiętaj, że odwiedzający mogą mieć monitor o rozmiarze innym od tego, który ty posiadasz. Dlatego sprawdź, jak wygląda twoja witryna WWW na monitorach różnego rozmiaru. Następnie, na podstawie tego podglądu, będziesz mógł wyregulować końcowy wygląd twojej witryny. FrontPage posiada jeszcze jedno narzędzie, które jest pomocne w radzeniu sobie z różnicami pomiędzy przeglądarkami. Znajdując się w widoku Strona (Page), wybierz Opcje strony (Page Options) z menu Narzędzia (Tools). Następnie wybierz zakładkę Kompatybilność (Compatibility). Zobaczysz okno dialogowe pokazane na rysunku 3.15. Tutaj możesz wybrać przeglądarkę docelową dla tej strony, jej wersję oraz serwer, na który strona będzie wysyłana. W oparciu o dokonane wybory, różne pola wyboru poniżej będą aktywowane bądź dezaktywowane. To samo stanie się z pozycjami menu programu FrontPage.
Rysunek 3.15. Kompatybilność strony Możesz również wybrać typ i wersję przeglądarki oraz typ serwera według własnych potrzeb. W tym wypadku ręcznie określasz technologie, które mają obsługiwać stronę, zaznaczając bądź odznaczając dowolne pola wyboru znajdujące się na dole okna.
Dodawanie strony Możesz dodać nową stronę WWW lub ASP do sieci Web stworzonej w programie FrontPage wybierając Nowa (New), Strona (Page) z menu Plik (File). Kiedy to uczynisz, zobaczysz kolejny ekran wyboru, który prezentuje rysunek 3.16. W tym dialogu możesz dokonać wyboru spośród wielu szablonów stron. Te wzorcowe strony przeprowadzą cię przez kreator, dzięki któremu stworzysz nową stronę, uzupełniając szablon odpowiednimi informacjami. Możesz również wybrać szablon nazwany Stroną normalną (Normal Page), który jest po prostu pustą stroną. Zakładka Strony ramek (Frames Pages) zawiera więcej szablonów, ale są one zbudowane przy użyciu ramek.
Rozdział 3 – Narzędzia pracy
72
Rysunek 3.16. Dialog wyboru szablonu strony WWW Kiedy przejdziesz przez wszystkie kroki kreatora, twoja nowa strona zostanie wyświetlona. Kiedy będziesz chciał ją zapisać, zostaniesz zapytany o tytuł strony i nazwę pliku. To w tym miejscu ustalasz, czy dana strona jest stroną ASP czy jakiegoś innego typu. Po prostu określ odpowiednio rozszerzenie pliku. Pamiętaj jednak, że nawet jeśli dasz plikowi rozszerzenie .asp, to i tak kod strony serwera nie zadziała dopóki nie zostanie przetworzony przez serwer. Kiedy już stworzyłeś stronę ASP, możesz przejść do widoku HTML i ręcznie dodać twój kod do strony.
Praca ze stroną Znajdując się w widoku normalnym strony możesz zacząć wpisywać do niej tekstową zawartość. Możesz również formatować tekst podobnie jak w każdym innym programie Microsoft Office przy użyciu paska formatowania, pokazanego na rysunku 3.17.
Rysunek 3.17. Pasek formatowania Pierwsza lista rozwijana paska narzędziowego pozwala na wybór typu elementu HTML, który zostanie użyty dla tego tekstu, na przykład H1 lub OL. Następnie możesz określić rodzaj i rozmiar czcionki oraz atrybuty akapitu. Jeśli potem spojrzysz na kod HTML strony, zobaczysz, że twoje zmiany zamieniły się w odpowiednie znaczniki HTML. Jak pokazano na rysunku 3.18, inne elementy HTML dodaje się do strony WWW w menu Wstaw (Insert).
73
ASP – Kompendium programisty
Rysunek 3.18. Menu Wstaw w widoku strony Wybór większości elementów w tym menu, uruchamia kreatora lub dialog uzyskujący od ciebie informacje potrzebne podczas dodawania nowego elementu do strony. Na przykład jeśli wybierzesz Hiperłącze (Hyperlink), program poprosi cię o podanie położenia pliku, do którego odnosi się łącze lub o wybranie strony w sieci Web. Dodawania elementów formularza dokonuje się w ten sam sposób, wybieramy któryś z podpunktów opcji Formularz (Form) dostępnej w menu Wstaw (Insert). Możesz dodać formularz na dwa sposoby. Po pierwsze, wstawienie pojedynczego elementu. Jeśli przykładowo chciałbyś wstawić pojedyncze pole tekstowe, wybierasz odpowiednią pozycję z menu Formularza, a FrontPage doda ten element w ramach jego własnego znacznika form do twojej strony WWW i wyświetli widok pokazany na rysunku 3.19.
Rysunek 3.19. Pojedyncze pole formularza
Rozdział 3 – Narzędzia pracy
74
Możesz wtedy określić działania, które należy podjąć oraz inne właściwości formularza klikając na nim prawym przyciskiem myszy, a następnie wybierając Właściwości Formularza (Form Properties). W ten sam sposób możesz dodać inne formularze. Jeśli formularz ma być bardziej złożony, możesz również wybrać w podmenu punkt Formularz (Form). Stworzony zostanie wtedy formularz z przyciskami Prześlij (Submit) oraz Skasuj (Reset). Następnie dodajesz elementy to tego formularza wybierając je z podmenu w czasie, gdy sam formularz jest zaznaczony. Jeśli klikniesz prawym przyciskiem myszy którykolwiek z elementów formularza, możesz przejrzeć jego właściwości wybierając Właściwości pola formularza (Form Field Properties). Odpowiednie okno dialogowe pokazuje rysunek 3.20.
Rysunek 3.20. Właściwości pola formularza Różne typy elementów formularza mają różne, odpowiadające im dialogi. Przycisk Sprawdź poprawność (Validate) pozwala na stworzenie ograniczeń typu i wartości zapisu wprowadzanego w pole formularza po stronie klienta.
NetObjects Fusion Kolejnym narzędziem tworzenia witryn WWW jest NetObjects Fusion, http:\\www.netobjects.com. NetObjects posiada duży wybór narzędzi wspierających projektowanie. W dalszej części rozdziału zwrócimy uwagę na jedno z nich zwane ScriptBuilder, posiadające wspaniały interfejs do pracy z kodami stron ASP. Możesz pobrać pełną, 30-dniową wersję tego programu z wymienionej wyżej witryny WWW. Jak będziesz mógł się przekonać z treści tego rozdziału, największą korzyścią płynącą z pracy z NetObjects Fusion to kontrola, jaką sprawujesz nad układem elementów strony. Narzędzie to pozwala na umieszczanie elementów w dowolnej części strony, tak jak gdybyś projektował formularz w Visual Basic lub Access. NetObjects bazuje na niewidzialnych tabelach i grafikach generowanych w HTML w celu zapewnienia kompletnej swobody w rozmieszczaniu elementów na stronie.
Środowisko pracy Fusion posiada pięć głównych widoków: Witryna (Site), Strona (Page), Styl (Style), Zasoby (Assets) oraz Publikacja (Publish). Zmiany widoku dokonuje się klikając jedną z ikon z nazwami widoków, które znajdują się w pasku narzędziowym tuż pod menu. Widok Witryna (Site) jest pokazany na rysunku 3.21. Jest to miejsce, od którego prawdopodobnie rozpoczniesz proces tworzenia, ponieważ właśnie w tym widoku możesz przeglądać strony znajdujące się w witrynie, dodawać je oraz usuwać. Strony są prezentowane w hierarchii logicznej. Jako że jest to widok logiczny, a nie fizyczny, nie możesz zapobiec połączeniom ze stronami spoza hierarchii. Widok ten wykorzystywany jest przez twórców do przemyślenia i zorganizowania logicznej struktury witryny WWW.
75
ASP – Kompendium programisty
Rysunek 3.21. Widok Witryna programu NetObjects Fusion Dodania strony do witryny dokonuje się przy użyciu klawisza Insert. Strona zostanie dodana jako potomna do dowolnej strony, która w tym czasie będzie zaznaczona. Na rysunku 3.21. zaznaczona jest strona Home, tak więc naciśnięcie klawisza Insert spowoduje dodanie właśnie do niej strony potomnej. Możesz usunąć stronę klikając ją prawym przyciskiem, a potem przyciskając klawisz Delete. Każda strona posiada swoje właściwości, które wyświetlane są w zakładce Właściwości (Properties) w małym oknie dialogowym. Pokazane jest ono w prawym dolnym rogu rysunku 3.21. W dialogu Właściwości (Properties) możesz zmienić nazwę bieżącej strony przez wpisanie jej do pola tekstowego Nazwa (Name). Jeśli naciśniesz przycisk Dostosowanie nazwy (Custom Names), powinieneś ujrzeć okno pokazane na rysunku 3.22.
Rysunek 3.22. Okno dialogowe Dostosowanie nazwy Tworząc stronę w NetObjects, możesz dodać baner lub przycisk wyszukiwania. W oknie dialogowym dostosowania nazw możesz określić tekst, który będzie się pojawiał na tych elementach strony. Tutaj możesz również nadać plikowi odpowiednie rozszerzenie. We właściwościach strony możesz umieścić również informacje związane z zarządzaniem twojej witryny. Możesz wybrać kolor tła strony używany w widoku hierarchii. Możesz również określić czy dana strona jest ukończona i czy powinna być publikowana. Dodatkowe pole tekstowe pozwala na dodanie komentarza do strony. Dodatkowa zakładka w widoku witryny nosi nazwę Struktury (Outline), który pokazuje strukturę stron w postaci podobnej do tej w Eksploratorze Windows. Po lewej znajduje się lista stron pokazanych w ich poszczególnych położeniach, natomiast po prawej widoczne są wszystkie strony potomne strony bieżącej.
Rozdział 3 – Narzędzia pracy
76
Tworząc stronę korzystasz z widoku Strona (Page). Aby znaleźć się w tym widoku, kliknij dwa razy na tej stronie w widoku witryny, z którą chcesz pracować. Zobacz rysunek 3.23.
Rysunek 3.23. Widok Strona programu Fusion Będąc już w widoku strony, możesz dostać się do innych stron na kilka sposobów. Możesz skorzystać ze strzałek znajdujących się w lewym dolnym rogu, aby poruszać się między poziomami w hierarchii lub pomiędzy stronami znajdującymi się na ty samym poziomie. Strzałki pozwalają na poruszanie się w hierarchii pokazanej w widoku witryny. Możesz również nacisnąć przycisk z czterema strzałkami, znajdujący się obok strzałek pojedynczych. Kiedy przycisk jest naciśnięty, małe okno wyszczególnia listę stron w formie hierarchii. Możesz również poszukiwać stron naciskając przycisk Przejdź do (Go to) w prawym górnym rogu ekranu. Kiedy przycisk zostaje naciśnięty, program pyta cię o podanie części nazwy strony, którą chcesz znaleźć. Jeśli naciśniesz przycisk Ostatnia (Last), umieszczony w prawym górnym rogu ekranu, przeniesiesz się do strony, którą ostatnio otwierałeś. Wzdłuż lewej strony okna umieszczono liczne elementy i składniki, które możesz włączyć do swojej strony. Większa ilość tych elementów dostępna jest w menu Widok (View), Paski narzędzi (Toolbars), gdzie wybrać można te paski, które aktualnie nie są prezentowane. Przyjrzymy się dokładnie niektórym z tych elementów nieco dalej w tym podrozdziale. Sama strona ma wiele właściwości, które możesz ustawić. Jeśli chcesz im się przyjrzeć, kliknij daną stronę prawym przyciskiem myszy i wybierz Właściwości układu strony (Layout Properties). W zakładce Ogólne (General) możesz ustalić rozmiar strony i sposób wykonania jej układu. Druga zakładka tego okna to Tło (Background). Tutaj ustalasz kolor tła strony, obrazy tła oraz jego dźwięki. Kolejnym widokiem głównym programu Fusion jest Styl (Style), który odnosi się do domyślnych czcionek, kolorów, przycisków i grafik witryny, ich domyślnego wyglądu. Widok ten jest zaprezentowany na rysunku 3.24. Lewą stronę ekranu zajmuje długa lista stylów. Po prawej mamy podgląd wybranego stylu, który uzyskujemy przez kliknięcie go w lewym panelu. Kiedy już wybrałeś styl dla twojej witryny, kliknij przycisk Ustaw Styl (Set style).
77
ASP – Kompendium programisty
Rysunek 3.24. Widok Styl programu Fusion Możesz również edytować każdy element istniejącego stylu. Przypuśćmy na przykład, że chciałbyś użyć stylu Urban Legend, ale tło ma być inne. Modyfikacji tła stylu dokonasz wybierając Styl (Style), Edytuj element (Edit Element), oraz Tło (Background). Pokaże się wtedy okno dialogowe, takie jak na rysunku 3.25. Podobnie edytuje się inne elementy stylu.
Rysunek 3.25. Modyfikacja stylu Jeśli nie chcesz korzystać z gotowych stylów, możesz stworzyć swój własny. Po prostu wybierz Styl (Style) i Nowy styl (New Style). Zostaniesz poproszony o podanie nazwy dla twojego stylu, a potem możesz już zacząć tworzyć jego elementy. Kolejny widok główny Fusion to Zasoby (Assets), który wyszczególnia pliki, łącza, obiekty danych oraz zmienne mające związek z twoją witryną. Ten widok pokazany jest na rysunku 3.26.
Rozdział 3 – Narzędzia pracy
78
Rysunek 3.26. Widok Zasoby programu Fusion NetObjects Fusion obserwuje wszystkie pliki i łącza, które kiedykolwiek były związane ze stroną. Jeśli więc zdecydujesz się na dodanie łącza bądź obrazka do witryny, możesz wybrać je z listy plików i łącz, które już są jej częścią. Możesz również użyć tego widoku do usuwania niepotrzebnych elementów z twojej witryny. Po prostu wybierz odpowiedni element i naciśnij klawisz Delete. Możesz również korzystać z tego widoku podczas globalnego zastępowania zasobu. Załóżmy, że posiadasz łącze z witryną usytuowaną poza twoją własną, z którą łączysz się z różnych miejsc twojej witryny. Jeśli chcesz zmienić to łącze na jakieś nowe i zmiana ma być globalna, znajdź je na liście w zakładce Łącza (Links). Następnie kliknij dwukrotnie wybrane łącze i wpisz nowy adres URL. Ostatni widok programu to Publikacja (Publish), gdzie określasz sposób i miejsce publikowania twojej witryny. Ten widok, pokazany jest na rysunku 3.27, prezentuje sposób fizycznego zapamiętywania witryny podczas jej publikowania. Na rysunku pliki są pokazane tak, jak byłyby umieszczone, gdyby były publikowane według typu. Możesz również wybrać publikację wszystkich plików w jednym katalogu lub w ich hierarchii logicznej. Aby zmienić sposób publikacji plików oraz ustawić inne właściwości, naciśnij przycisk Ustawienia (Setup). Powinieneś ujrzeć okno dialogowe pokazane na rysunku 3.28.
79
ASP – Kompendium programisty
Rysunek 3.27. Widok Publikacja programu Fusion
Rysunek 3.28. Okno dialogowe Ustawienia publikacji W pierwszej zakładce, Struktura katalogu (Directory Structure), możesz określić sposób fizycznego położenia twoich plików. Druga zakładka, Wyjście HTML (HTML Output), umożliwia zmianę generowanego układu strony oraz wykorzystywanego zestawu znaków. Zakładka trzecia, Położenie serwera (Server Location), daje możliwość określenia miejsca lub miejsc, gdzie będzie się znajdowała twoja witryna. Ta zakładka pokazana została na rysunku 3.29.
Rozdział 3 – Narzędzia pracy
80
Rysunek 3.29. Zakładka Położenie serwera dialogu Ustawienia publikacji Istnieją dwa typy publikacji: lokalna i zdalna. Każdą z nich możesz dodać klikając przycisk Dodaj (Add). Wybierając opcję Lokalna (Local) będziesz musiał po prostu podać katalog, w którym witryna będzie publikowana w twojej sieci. Jeśli wybierzesz opcję Zdalna (Remote), musisz określić położenie macierzystego komputera oddalonego, twoją nazwę użytkownika oraz hasło. Czwarta zakładka okna dialogowego wyszczególnia listę składników, które będą publikowane wraz ze stroną, jeśli w ogóle takowe istnieją. Kiedy już zakończysz dokonywanie ustawień, jesteś gotowy do publikacji twojej witryny. Dokonuje się tego klikając przycisk Publikuj (Publish). Po naciśnięciu przycisku wyświetlona zostanie lista miejsc publikacji witryny, które określiłeś w zakładce Położenie serwera (Server Location). Naciśnij OK, a twoja strona zostanie opublikowana.
Tworzenie witryny WWW przy użyciu programu Fusion Aby stworzyć nową stronę przy użyciu programu Fusion, wybierz z menu Plik (File) pozycję Nowa witryna (New Site). Jak to pokazano na rysunku 3.30, będziesz miał do wyboru trzy opcje. Wybierając opcję Pusta witryna (Blank Site), stworzona zostanie pojedyncza strona WWW; wybierając Według szablonu (From Template), zaprezentowany zostanie zbiór gotowych schematów witryn, które możesz wykorzystać jako szkielet twojej witryny; jeśli zdecydujesz się na opcję Z istniejącej witryny WWW (From Existing Web Site), program Fusion zaimportuje całą, wybraną witrynę WWW.
Rysunek 3.30. Tworzenie nowej strony
Praca ze stroną Jeśli kiedykolwiek pracowałeś z Visual Basic lub projektowałeś formularze w Microsoft Access, stosunkowo wygodnie będzie ci się pracowało ze stronami przy użyciu programu Fusion. Wszystkie elementy są kreślone
81
ASP – Kompendium programisty
na stronie. Kiedy już element się tam znajdzie, ustawiasz dla niego liczne właściwości w celu osiągnięcia pożądanego efektu. Jeśli na przykład chcesz dodać tekst do strony, wybierzesz ikonę Tekst (Text) znajdującą się w pasku narzędziowym widoku Strona (Page) po lewej stronie ekranu. Następnie wykreślisz element o odpowiednim rozmiarze. Rysunek 3.31. pokazuje stronę z nakreślonym elementem tekstowym.
Rysunek 3.31. Strona z wstawionym polem tekstowym Teraz, kiedy element jest wykreślony na stronie, możesz ustawić jego właściwości. Po pierwsze, możesz wpisać tekst, który ma się pojawiać w elemencie. Następnie określasz styl tekstu, jego tło i wiele innych właściwości przy użyciu odpowiedniego okna dialogowego. Podobne czynności wykonuje się przy dodawaniu do strony innych elementów.
NetObjects ScriptBuilder Kolejnym narzędziem NetObjects jest ScriptBuilder. To nie tylko wspaniałe narzędzie do tworzenia stron ASP. Dzięki niemu można również tworzyć skrypty wykonywane po stronie klienta oraz czysty kod HTML. W tym podrozdziale zwrócimy uwagę na tworzenie stron ASP przy użyciu NetObjects ScriptBuilder. Zobaczysz również, jak można wykorzystać funkcje tego narzędzia do ułatwienia dodawania skryptów oraz ich zatwierdzania.
Środowisko programowe Okno główne programu ScriptBuilder składa się z dwóch paneli: lewego i prawego. Lewy panel zazwyczaj zawiera listę działań lub opcji, zależnie od wybranej zakładki. Panel prawy pokazuje stronę ASP lub HTML, nad którą pracujesz. Aby otworzyć stronę w prawym panelu, wybierz Plik (File), Otwórz (Open). Okno dialogowe, które się ukaże, pozwoli ci na znalezienie pliku, który chcesz otworzyć. Kiedy chcesz stworzyć nowy plik, wybierz Plik (File), Nowy (New). Wyświetlony zostanie dialog, który pokazano na rysunku 3.32.
Rozdział 3 – Narzędzia pracy
82
Rysunek 3.32. Dialog Nowy Plik programu ScriptBuilder Następnie możesz wybrać jeden z przedstawionych w oknie szablonów, reprezentujących typ strony, jaką chcesz stworzyć. Wybrany szablon wygeneruje podstawowe znaczniki dla wybranego przez ciebie typu strony. Jeśli zdecydowałeś się przykładowo na utworzenie strony ASP, szablon stworzy stronę zawierającą znaczniki języka podstawowego, HTML, nagłówka (head), oraz treści (body). Możesz również modyfikować te szablony, w ten sposób za każdym razem, kiedy stworzysz nową stronę przy użyciu szablonu, będzie ona zawierała kod potrzebny dla tego typu pliku. Załóżmy na przykład, że posiadasz plik biblioteki, który zawsze chcesz dołączać do twoich stron ASP. Aby to zrobić, za każdym razem musisz dodawać do kodu wiersz Include dla tego pliku. Zmodyfikuj szablon strony ASP włączając do niego odpowiedni kod. W celu dokonania zmian we szablonie, wyświetl zawartość plików położonych w folderze Templates\Standard katalogu głównego ScriptBuilder. Możesz również tworzyć swoje własne szablony. Być może często potrzebujesz strony ASP mającej kod, który wykreśla graf w oparciu o dane pochodzące z zestawu rekordów — możesz stworzyć taki szablon zawierający wspólny kod. Aby wykonać taki szablon, po prostu stwórz w zwykły sposób stronę ASP lub HTML, a następnie umieść ją w folderze Templates\Custom. Te pliki dostępne są w menu Plik (File), Nowy (New), w zakładce Własne (Custom). W lewym panelu możesz wybrać zakładkę związaną z działaniami bądź opcjami, które wykorzystujesz podczas pracy ze stroną. Wybierając zakładkę Odwołanie (Reference), ujrzysz widok pokazany na rysunku 3.33. To, co tam widać to bogata biblioteka języków i technologii, które możesz wykorzystać podczas pracy z programem ScriptBuilder.
83
ASP – Kompendium programisty
Rysunek 3.33. Widok Odwołanie w lewym panelu okna Przypis
Jeśli nie widać listy rozwijanej, gdzie mógłbyś wpisać nazwę do wyszukania, kliknij małą strzałkę w górnym prawym rogu lewego panelu.
Większość odwołań pochodzi z zasobów online, co ma swoje plusy i minusy. Musisz być połączony z siecią, aby ujrzeć niektóre odwołania i punkty odwołań do stron, które już nie istnieją. Korzystne jest jednak to, że zawartość listy jest cały czas uaktualniana, ponieważ pochodzi ze znaczących obszarów odwołań firm takich jak Microsoft czy Netscape. Możesz również użyć odwołania w celu wstawienia znaczników i kodu wprost do twojej strony. Na przykład chcesz wstawić listę numerowaną HTML. Mógłbyś wybrać znacznik w odniesieniu HTML. Następnie jeśli klikniesz prawym przyciskiem odpowiednią pozycję i wybierzesz Wstaw (Insert), znaczniki listy numerowanej pojawią się w prawym panelu okna w miejscu, gdzie znajduje się kursor. Możesz też uzupełnić bibliotekę o nowe odwołania. Jeśli klikniesz prawym przyciskiem w dowolnym miejscu zakładki odwołań, powinieneś zobaczyć opcję Ustawienia (Settings). Kliknij ten punkt, a będziesz mógł przejrzeć wszystkie dostępne książki biblioteki. Ustawień innych opcji zakładki odwołań dokonasz wybierając Opcje (Options) z menu Narzędzia (Tools). Jeśli wybierzesz zakładkę Odwzorowanie (Map), zobaczysz widok, który prezentuje rysunek 3.34. Odwzorowanie odnosi się tutaj do reprezentacji dokumentu, z którym pracujesz. Odwzorowane są znaczniki i składniki, które znalazły się w dokumencie, dzięki czemu możesz szybko znaleźć te miejsca w kodzie, gdzie zostały one użyte. Gdybyś chciał odszukać miejsca, w których użyto znacznika
, kliknij dwa razy odpowiednią pozycję lewego panelu okna, a wiersz zawierający ten znacznik zostanie wyróżniony.
Rysunek 3.34. Widok Odwzorowanie programu ScriptBuilder Zakładka Pulpit (Desktop), pokazana na rysunku 3.35, pozwala na poszukiwanie w systemie plików, które chcesz wykorzystać podczas pracy z witryną. Jeśli klikniesz dwa razy dowolny plik, zostanie on otwarty w prawym panelu okna. Jeśli klikniesz prawym przyciskiem myszy obszar Pulpitu, możesz utworzyć folder oraz przejrzeć właściwości pliku.
Rozdział 3 – Narzędzia pracy
84
Rysunek 3.35. Widok Pulpit programu ScriptBuilder Jednym z najużyteczniejszych składników programu ScriptBuilder jest biblioteka skryptów. Zakładka Biblioteka skryptów (Script Library) pokazana została na rysunku 3.36. Pozwala ona na proste wstawianie gotowych bloków kodu do twojej strony WWW. ScriptBuilder zawiera wiele skryptów strony klienta i strony serwera, które możesz włączyć do twoich stron ASP i HTML.
Rysunek 3.36. Widok Biblioteka skryptów programu ScriptBuilder Lista biblioteki skryptów może być sortowana po dowolnej kolumnie, którą wybierzesz klikając jej nagłówek. Kolumny przedstawiają nazwę skryptu, użyty podczas jego tworzenia język lub technologię, jego opis oraz wersję programu Navigator lub Explorer obsługującego skrypt. Aby wstawić skrypt do twojej strony, umieść kursor w tym miejscu, gdzie ma się znaleźć oraz kliknij dwukrotnie wybrany z biblioteki skrypt. Jeśli na przykład chcesz skorzystać z procedury odczytującej znacznik
85
ASP – Kompendium programisty
kontekstu klienta (cookie), najpierw umieść kursor w odpowiednim miejscu strony ASP, gdzie procedura ma występować. Następnie kliknij dwukrotnie w lewym panelu prezentującym zbiór skryptów procedurę o nazwie ReadCookie. Od tej chwili stanie się ona częścią twojego kodu. Te wbudowane skrypty są całkowicie konfigurowalne i podatne na zmiany. Aby zmienić właściwości skryptu, kliknij go dwukrotnie i wybierz Właściwości (Properties). Ujrzysz dialog pokazany na rysunku 3.37. Tutaj możesz zmienić nazwę i opis skryptu. Możesz również wybrać jego język bądź technologię, jak również wersję przeglądarki Navigator lub Explorer, która będzie obsługiwała skrypt.
Rysunek 3.37. Dialog Właściwości skryptu Modyfikacja kodu skryptu możliwa jest w zakładce Kod (Code). Okno powiększy się tak, aby pokazać kod danej procedury (Rysunek 3.38.). Właśnie tutaj możesz wprowadzić pożądane zmiany w treści dostępnych w bibliotece skryptów. Na przykład osobiście wolę, żeby procedury ASP (do nich należy ta pokazana na rysunku 3.38.) miały od razu w swej treści znaczniki bloku kodu ASP . Mogę je tam umieścić modyfikując skrypt w tej zakładce. Kiedy zamkniesz okno kodu, program poprosi cię o potwierdzenie lub odrzucenie dokonanych zmian.
Rysunek 3.38. Okno kodu edytowanego skryptu Moją ulubioną cechą programu jest możliwość dodawania do biblioteki własnych skryptów. Zauważyłem, że wiele krótkich bloków kodu, z których stale korzystam, nie znalazło się w procedurach. Aby nie przepisywać ciągle tych samych fragmentów kodu, można je umieścić w bibliotece. Możesz dodać skrypt do biblioteki na dwa sposoby. Pierwszym z nich jest kliknięcie prawym przyciskiem w obszarze okna biblioteki i wybranie punktu Dodaj (Add). Ujrzysz wtedy puste okno kodu, takie samo, jak w wypadku edycji istniejącego skryptu. Tam wprowadzisz nowy kod skryptu. Po ukończeniu przejdź do zakładki
Rozdział 3 – Narzędzia pracy
86
Opis (Description). Tutaj wpiszesz nazwę nowego skryptu oraz jego krótki opis, wraz z wyszczególnieniem zastosowanego języka lub technologii i wersji obsługującej ten skrypt przeglądarki Navigator lub Explorer. Drugim sposobem dodania procedury do biblioteki skryptu jest odzyskanie odpowiedniego fragmentu kodu z istniejącej już strony. Możesz to zrobić wyróżniając tekst w wybranym dokumencie, a następnie klikając prawym przyciskiem zaznaczony tekst i wybierając opcję Dodaj do biblioteki skryptów (Add to Script Library). Powiedzmy, że w wielu stronach ASP łączysz się z bazą danych w ten sam sposób i chcesz, aby ten kod łączenia stał się częścią biblioteki skryptów. Wyróżnij ten fragment kodu przy użyciu myszy, a następnie kliknij prawym przyciskiem. Okno, które się wtedy pojawi, pokazane jest na rysunku 3.39.
Rysunek 3.39. Dodawanie kodu do biblioteki skryptów Jeśli wybierzesz opcję Dodaj do biblioteki skryptów (Add to Script Library), kod jest dodawany jako pozycja do biblioteki. Ponownie wpisujesz wszystkie niezbędne informacje dotyczące nowego skryptu. Kiedy skończysz, kod staje się częścią biblioteki i może być wstawiany do tworzonych stron. Ostatnią zakładką lewego panelu głównego okna programu ScriptBuilder jest Galeria składników (Component Gallery). Zawartość zakładki prezentuje rysunek 3.40. Galeria ułatwia pracę z programowalnymi, gotowymi do wstawienia składnikami. Możesz włączyć dany składnik do tworzonej strony ASP lub HTML, przeciągając go w to miejsce, w którym ma być inicjalizowany.
87
ASP – Kompendium programisty
Rysunek 3.40. Galeria składników programu ScriptBuilder Możesz określić właściwości, metody oraz zdarzenia związane z danym składnikiem, klikając go prawym przyciskiem myszy, a następnie wybierając odpowiedni punkt. Szablon właściwości, metody bądź zdarzenia jest wtedy dodawany do twojej strony. Możesz również dodać własny składnik do środowiska programu, klikając prawym przyciskiem w dowolnym miejscu Galerii składników oraz wybierając opcję Dodaj do galerii (Add to Gallery).
Praca z kodem w programie ScriptBuilder ScriptBuilder posiada wiele narzędzi wspomagających pisanie kodu i pracę z nim. ScriptBuilder wyświetla wiersze kodu w różnych kolorach, co powoduje, że kod jest bardziej czytelny i rozpoznawalny. Aby jednak z tej cechy programu skorzystać, najpierw musi on wiedzieć, z jakim językiem pracujesz. Tak więc jedną z pierwszych rzeczy, którą zrobisz będzie ustawienie domyślnego języka, który będzie wyróżniany. Wybierz z menu Widok (View) opcję Wyróżniony język (Highlighted Language), a następnie przykładowo VBScript, co pokazano na rysunku 3.41.
Rysunek 3.41. Ustawianie domyślnego języka do wyróżniania
Rozdział 3 – Narzędzia pracy
88
Kiedy język zostanie określony, kod w odpowiedni sposób wyróżniany kolorami, co czyni go łatwiejszym do odczytu. Poza tym, skoro ScriptBuilder już wie, jakiego języka używasz, może automatycznie pomagać ci w uzupełnianiu bloków kodu. Jeśli na przykład napiszesz poniższy kod wraz ze spacją: If
program uzupełni ten blok: If expression Then End If
Wyróżni nawet frazę expression, będziesz mógł więc natychmiast wpisać w to miejsce wybrane wyrażenie. Jeśli wpisałbyś ten kod wraz ze spacją: Select
ScriptBuilder zbuduje następujący blok kodu, wyróżniając w nim słowo expression: Select Case expression Case value
Case Else End Select
Możesz również zmodyfikować funkcję automatycznego tworzenia skryptów tak, aby inne kody pojawiały się przy wyborze poszczególnych instrukcji. Przykładowo możesz chcieć, aby instrukcja If zawsze była uzupełniana instrukcją Else. Takiego ustawienia możesz dokonać wybierając Narzędzia (Tools) oraz Automatyczne tworzenie skryptów (AutoScripting). Zobaczysz wtedy kompletną listę dostępnych opcji automatycznego tworzenia skryptów (zobacz rysunek 3.42).
Rysunek 3.42. Konfiguracja funkcji Automatycznego tworzenia skryptów Zauważ, że lista zawiera informacje o używanych językach. Przewijasz listę w poszukiwaniu instrukcji If dla języka VBScript. Następnie kliknij Edytuj (Edit). Wyświetli się ekran pokazany na rysunku 3.43. Tutaj możesz uzupełnić instrukcję If instrukcją Else lub dokonać jakiejkolwiek innej modyfikacji. Zwróć uwagę, że słowo expression jest wyróżnione. Kiedy wpisałeś If w kodzie strony, właśnie słowo expression było zaznaczone.
ASP – Kompendium programisty
89
Rysunek 3.43. Edycja kodu w Automatycznym tworzeniu skryptów Możesz również dodać swoje własne bloki kodu poprzez funkcję Automatycznego tworzenia skryptów, naciskając przycisk Nowy (New) w oknie dialogowym. Ukaże się ten sam dialog, co w wypadku edycji. Musisz tutaj wpisać słowo kluczowe, instrukcję, po pojawieniu się której ma wystąpić odpowiedni kod. Oprócz tego określasz język programowania dla tego kodu oraz oczywiście sam kod. Możesz również użyć tej funkcji programu, aby zastosować skróconą metodę tworzenia kodu. Jak się dowiesz z kolejnego rozdziału, często na przykład będziesz włączał do kodu wiersz Option Explicit, aby ułatwić usuwanie błędów. Możesz zapewnić sobie skrót dla tej instrukcji dzięki stworzeniu odpowiedniej pozycji w oknie Automatycznego tworzenia skryptów. Najpierw wpisz następującą kluczową frazę: ooo
Poniżej, w polu Wstawiany tekst (Text to Insert), wpisz: Option Explicit
oraz nowy wiersz. Teraz, kiedy podczas tworzenia kodu wprowadzisz ooo, pojawi się na ekranie instrukcja Option Explicit, a po niej nowy wiersz. W menu Skrypt (Script), a następnie pozycji Menu dostępna jest opcja Blok serwera (Server Block), której wybór powoduje wpisanie następującego kodu:
Tworzony jest więc blok serwera. Kiedy wybierzesz menu Narzędzia (Tools), Opcje (Options) oraz przejdziesz do zakładki Kod (Code), ukaże się ekran pokazany na rysunku 3.44. W tej zakładce możesz dokonać zmiany używanej składni bloku kodu przez ustawienie jej w polu o nazwie Typ znacznika (Tag Type).
Rozdział 3 – Narzędzia pracy
90
Rysunek 3.44. Opcje ustawień kodu W tym samym dialogu znajduje się punkt Bloki funkcji (Function Blocks). W odpowiednim polu wpisujesz tekst, który ma pojawiać się w bloku komentarza wstawianej procedury. Jeśli chcesz, aby pojawiało się twoje imię, wpisz je w pole Nazwa użytkownika (Username). Następnie możesz zaznaczyć, że twoje imię wraz z aktualną datą chcesz włączyć do nagłówka komentarza funkcji. Ta informacja jest wykorzystywana w oknie dialogowym pokazanym na rysunku 3.45, które pojawi się kiedy wybierzesz opcję Bloki funkcji (Function Blocks) z menu Skrypt (Script).
Rysunek 3.45. Wstawianie bloku funkcji Wpisujesz nazwę funkcji, a następnie opis jej działania. Kiedy naciśniesz OK, wprowadzone tutaj dane są łączone z danymi wprowadzonymi w dialogu Opcji i wytwarzany jest następujący, przykładowy blok kodu: '************************************************************* '
SampleFunction ()
' '
Tutaj wpisz szczegóły dotyczące twojej funkcji
' '
Autor: Greg Buczek
'
Data utworzenia: 8/4/99
'************************************************************* */ Function SampleFunction () End Function
Jak więc widzisz, ScriptBuilder nie jest narzędziem wizualnego projektowania stron. Możesz w prosty sposób uruchomić podgląd strony, ale nie możesz umieszczać na niej elementów metodą przeciągania i upuszczania. W programie ScriptBuilder pracujesz jedynie z kodem oraz czystym HTML.
ASP – Kompendium programisty
91
Pasek narzędziowy Znaczniki HTML (HTML Tags) pomaga jednak wstawiać znaczniki. Pasek ten pokazany jest na rysunku 3.46. Po naciśnięciu wybranego przycisku, odpowiedni znacznik jest wstawiany do twojego dokumentu w miejscu, gdzie znajduje się kursor, jeśli więc naciśniesz przycisk B, znaczniki oraz staną się częścią dokumentu. Jeśli najpierw wyróżnisz tekst do pogrubienia, a dopiero potem wybierzesz przycisk z paska, znaczniki będą umieszczone wokoło zaznaczonego tekstu.
Rysunek 3.46. Pasek narzędziowy Znaczniki HTML Naciśnięcie jednego z przycisków wyrównania tekstu powoduje wytworzenie odpowiednich znaczników akapitu. Na przykład naciśnięcie przycisku wyrównania do lewej, tworzony jest następujący HTML:
Po ikonach wyrównania w pasku umieszczono ikony wypunktowania, numerowania, akapitu, wiersza podziału oraz linii poziomej, których naciśnięcie również spowoduje pojawienie się odpowiedniego znacznika. Przyciski od H1 do H6 wytwarzają odpowiadające im znaczniki nagłówka, tak więc naciśnięcie przycisku H1 wywoła następujący HTML:
Kursor będzie znajdował się pomiędzy znacznikami, tak więc możesz od razu zacząć wpisywać tekst. Ostatnie dwa przyciski związane są odpowiednio ze znacznikami obrazu i łącza. Naciśnięcie tych przycisków spowoduje pojawienie się odpowiedniego dialogu, w którym podasz konieczne informacje. Kiedy wybierzesz ikonę Obraz (Image), zobaczysz okno pokazane na rysunku 3.47.
Rysunek 3.47. Wstawianie znacznika obrazu Wpisujesz w nim ścieżkę dostępu do obrazu, tekst pojawiający się wraz z obrazkiem lub zamiast niego, sposób wyrównania tekstu, granice, rozmiar obrazu oraz rozstaw. Znacznik obrazu tworzony jest na podstawie wprowadzonych zapisów. Kiedy naciśniesz przycisk Łącze (Link), ujrzysz dialog pokazany na rysunku 3.48. Uzupełniasz go lokalizacją, do której łącze będzie odsyłało, tekstem pojawiającym się na stronie jako łącze oraz, opcjonalnie, nazwę łącza i jego cel. Pole tekstowe Cel (Target) odnosi się do przeglądarki lub ramki, do której wysyłana jest strona. Kiedy wprowadzisz już informacje i naciśniesz OK, utworzony zostanie odpowiedni znacznik.
Rozdział 3 – Narzędzia pracy
92
Rysunek 3.48. Wstawianie znacznika łącza ScriptBuilder posiada również pasek narzędziowy elementów formularza (rysunek 3.49.). Użycie każdego ze znajdujących się w nim przycisków spowoduje wyświetlenie dialogu, w który należy wpisać odpowiednie informacje potrzebne do stworzenia pożądanego znacznika. Pierwszy przycisk służy do tworzenia samego formularza. Kiedy go naciśniesz, dialog zapyta cię o nazwę formularza, okno wyjściowej przeglądarki lub ramki, typ kodowania oraz położenie strony, do której należy odesłać użytkownika po wypełnieniu i wysłaniu formularza. Określasz również metodę przesyłania formularza, GET lub POST. Różnice pomiędzy tymi metodami omówione zostały w rozdziale 5.
Rysunek 3.49. Pasek narzędziowy Elementy formularza Rezultatem wypełnienia okna dialogowego jest stworzenie znacznika formularza w miejscu kursora, który może być podobny do tego:
Przy wyborze przycisków poświęconych elementom strony zostaniesz poproszony o podanie nieco innych informacji, zależnych od typu elementu, który wybrałeś. Przykładowo przy wyborze pola tekstowego będziesz musiał podać nazwę pola, jego wartość, długość oraz czy jest to pole z hasłem. Rezultatem może być następujący znacznik:
Jeśli jednak naciśniesz przycisk obszaru tekstowego, zostaniesz poproszony o określenie nazwy pola, domyślnego tekstu, jego rozmiaru oraz sposobu jego obramowania.
Weryfikacja kodu w programie ScriptBuilder ScriptBuilder posiada również parę narzędzi wspierających sprawdzanie napisanego przez ciebie kodu. Są to: Korektor składni (Syntax Checker) i Kontroler skryptu (Script Inspector). Jednym z błędów, które często zdarzają mi się podczas tworzenia stron ASP, jest opuszczanie nawiasów, jak w wierszu kodu poniżej: If isempty(Request.Form(" OK") then
ASP – Kompendium programisty
93
Ładuję stronę na serwer myśląc, że wszystko jest w porządku, a kiedy ją uruchamiam okazuje się, że wystąpił błąd w wierszu kodu. Wiem, w czym leży problem, ale muszę najpierw edytować tą stronę, a następnie ponownie umieścić ją na serwerze. Korektor składni jest w tym względzie bardzo pomocny. Nie znajdzie on błędów związanych z użyciem niewłaściwej metody czy właściwości obiektu i pewnie nie rozpozna błędów logicznych, ale błędy składni, podobne do tego zaprezentowanego powyżej, zostaną przez program odnalezione. Powiedzmy, że twój blok kodu wygląda następująco:
Jesteś już gotów do wysłania twojej strony do serwera, ale przedtem chcesz sprawdzić, czy nie ma w niej jakichś błędów składni. Z menu Narzędzia (Tools) wybierz opcję Korektor składni (Syntax Checker). W rezultacie tego wyboru w oknie programu ScriptBuilder pojawi się dodatkowy panel, który pokazany jest na rysunku 3.50.
Rysunek 3.50. Rezultat uruchomienia Korektora składni Zwróć uwagę na panel, który znajduje się a dole okna. Wyszczególnia on błąd w stronie w szóstym jej wierszu. Panel ten pokaże listę wszystkich błędów składni znalezionych w stronie. Jeśli klikniesz dwa razy wiadomość o błędzie, program przeniesie cię do tego wiersza, który ten błąd wywołał. Korektor składni wyszuka wiele błędów podobnych do tego. Poinformuje cię o tym, że użyłeś instrukcji If bez End If lub instrukcji For bez Next. Zauważyłem jednak, że czasami korektor widzi błędy składni tam, gdzie ich nie ma. Weźmy następując fragment kodu, który w stronie ASP jest pojedynczym wierszem kodu:
Ta linia spowoduje wystąpienie błędu, chociaż błędu nie ma. Taką reakcję programu ScriptBuilder wywoła pojawienie się kodu ASP wraz z HTML. Innym narzędziem weryfikacji jest Kontroler skryptu. Przeglądnie on twój HTML, kod strony serwera i strony klienta i poda wersje przeglądarek Navigator i Explorer, które będą mogły rozpoznać twój kod. Aby skorzystać z tego narzędzia, otwórz stronę, którą chcesz przetestować i wybierz opcję Kontroler skryptu (Script Inspector) z menu Narzędzia (Tools). W wyniku tego na dole okna ukażą się panele, które pokazane zostały na rysunku 3.51. Jeśli drugi panel nie został wyświetlony, kliknij prawym przyciskiem w obszarze panelu widocznego i wybierz Pokaż szczegóły (Show Details).
Rysunek 3.51. Wynik uruchomienia Kontrolera skryptu Zauważ, że Kontroler skryptu zgłosił znalezienie znacznika VBScript strony klienta, który nie jest obsługiwany przez większość obecnych wersji przeglądarek Navigatora. Jeśli klikniesz podwójnie wiadomość o błędzie wyświetloną w najniżej położonym panelu, program przeniesie cię do tego wiersza kodu, który jest źródłem wystąpienia problemu.
Microsoft Visual InterDev 6.0 Kolejnym pomocnym narzędziem, którego możesz użyć do tworzenia stron ASP jest Microsoft Visual InterDev 6.0. Ponieważ jest o produktem firmy Microsoft, łączą go bliskie relacje z Internetowym serwerem informacyjnym (IIS) oraz systemem NT. Z perspektywy twórcy stron najważniejszymi cechami tego programu są: wyróżnianie wizualne oraz automatyczne zakańczanie kodu. Rysunek 3.52. pokazuje stronę ASP otwartą przy użyciu Visual InterDev. Program, dzięki zastosowaniu kolorowych czcionek, kolorów tła oraz pogrubienia tekstu, czyni stronę bardzo czytelną. W prosty sposób można wtedy dostrzec, gdzie się zaczyna, a gdzie kończy blok kodu; instrukcje w blokach kodu są pogrubione.
ASP – Kompendium programisty
95
Rysunek 3.52. Okno programu Visual InterDev 6.0 Zauważ, że na dole okna znajdują się trzy zakładki odnoszące się do strony: Projekt (Design), Źródło (Source) i Szybki podgląd (Quick View). Niestety jeśli uruchomisz stronę zawierającą kod ASP wraz z HTML — czyli prawie każdą — zakładka Projekt (Design) nie zadziała; natomiast zakładka Szybki podgląd (Quick View) nie będzie funkcjonowała, ponieważ program nie przetwarza kodu strony serwera. Tak więc jedynym widokiem, który mamy do dyspozycji przez cały czas jest Źródło (Source). Inną nadzwyczaj pomocną funkcją Visual InterDev są listy zakańczania kodu, generowane w chwili użycia kropki w składni kodu dla jednego z wbudowanych obiektów ASP. Na przykład jednym z najważniejszych obiektów ASP jest Response. Używany jest do komunikowania się z przeglądarką, która wywołała twoją stronę ASP. Obiekt ma liczne właściwości i metody, które pozwalają na podjęcie działań. Jeżeli w oknie Visual InterDev wpiszesz następujący kod: Response.
pojawi się lista pokazana na rysunku 3.53. Będzie ona zawierała wszystkie właściwości i metody obiektu Response. Możesz zacząć wpisywać wybraną metodę albo po prostu przewinąć listę i wybrać z niej odpowiedni punkt.
Rozdział 3 – Narzędzia pracy
96
Rysunek 3.53. Lista rozwijana zakończenia kodu dla obiektu Response
Ostatnie słowo o narzędziach Bez względu na to, na które narzędzie się zdecydujesz, pamiętaj, że to tylko narzędzie — jeśli użyjesz właściwego, ułatwisz sobie pracę. Powinieneś przeanalizować ich pełne możliwości, ponieważ większość najciekawszych funkcji często bywa zagrzebana na samym dnie menu. Postaraj się nie zadowalać jednym tylko produktem. Nowe produkty i programy usługowe przez cały czas pojawiają się na rynku, a ich zastosowanie często zaoszczędzi ci mnóstwa czasu.
Rozdział 4. Podstawy ASP Konstrukcja kodu ASP Strony ASP złożone są ze statycznego HTML-a oraz dynamicznego kodu ASP. Te dwa składniki mogą być łączone ze sobą na różne sposoby, które zostaną omówione w tym podrozdziale: HTML może być umieszczony w kodzie, kod w HTML oraz skrypty strony serwera mogą być zawarte w skryptach kodu klienta.
Znacznik Aby odróżnić początek od końca kodu, będziesz potrzebował pewnego rodzaju znacznika. Najprostszy znacznik przedstawia się następująco:
Nakazuje on kompilatorowi wypisanie wyniku wyrażenia X. Na przykład, jeśli chcesz stworzyć stronę WWW wyświetlającą aktualną datę oraz czas, stwórz kod podobny do tego: <TITLE>Simple Tag Page Witam na stronie z zegarem
Teraz jest:
Strona jest napisana przy użyciu standardowego HTML-a aż do wiersza:
Teraz jest:
Pierwszą częścią wiersza jest standardowy HTML, ale pojawia się tutaj podstawowy znacznik ASP. Ponieważ po otwarciu Days Until Christmas Ile czasu zostało?
Dni do Bożego Narodzenia:
Strona zbudowana jest z samego HTML-a aż do wiersza:
Dni do Bożego Narodzenia:
Kompilator ASP widzi znacznik , jest kodem wymagającym przetworzenia. W tym przypadku korzystamy z metody o nazwie Write obiektu Response w celu wysłania wyniku do przeglądarki (obiekt ten zostanie szczegółowo omówiony w rozdziale 6.). Szczególną wartością wysłaną do przeglądarki jest liczba dni do Bożego Narodzenia, powstała po odjęciu liczby od siebie dni pozostałych pomiędzy aktualną datą a datą tegorocznego święta. Wiersz wynikowy kodu:
Dni do Bożego Narodzenia: 157
ASP – Kompendium programisty
99 Wygląd strony przedstawia rysunek 4.2.
Rysunek 4.2. Strona zawierająca pojedynczą linię kodu ASP
Możesz również użyć znaczników do stworzenia bloku kodu, który jest serią wierszy otrzymujących określone zadania. Powiedzmy, że musisz stworzyć stronę, która wysyła lub przeadresowuje odwiedzającego do innej strony, opierając się przy tym na dniu tygodnia. Poniższy blok kodu realizuje to zadanie:
To byłaby cała zawartość strony. Nie posiada ona widoku wyjściowego i jest napisana jedynie w kodzie ASP. Kod sprawdzi dzień tygodnia w oparciu o aktualną datę, a następnie połączy odwiedzającego ze stroną odpowiedniego dnia.
Rozdział 4 – Podstawy ASP
100
< Script> Kod Jeśli już pracowałeś ze skryptami po stronie klienta, to prawdopodobnie jesteś zaznajomiony ze znacznikiem <Script>. Jest on alternatywą dla znaczników zaprezentowanych do tej pory, dlatego możesz go używać podczas konstruowania stron ASP. Musisz jednak użyć parametru RunAt i ustawić go dla serwera, ponieważ w innym wypadku twój kod ASP będzie pominięty przez przeglądarkę podczas przetwarzania. Poniżej pokazano kod strony WWW używającej znacznika <Script>. <TITLE>Session Object Czas trwania sesji
Czas trwania sesji upływa po (minutach): <SCRIPT LANGUAGE=VBScript RUNAT=Server > Response.Write Session.Timeout
Strona wygląda jak zwykła strona HTML aż do znacznika <Script>: <SCRIPT LANGUAGE=VBScript RUNAT=Server >
Zauważ, że określony został użyty język oraz to, że kod zostanie uruchomiony po stronie serwera. Następnie mamy jeden wiersz kodu, który wypisuje w minutach czas trwania sesji (Timeout): Response.Write Session.Timeout
Kod zakończony jest znacznikiem . Obliczonym przez kod wynikiem uwidocznionym w przeglądarce jest: 30
Wyjściowa strona pokazana jest na rysunku 4.3.
ASP – Kompendium programisty
101
Rysunek 4.3. Strona ASP używająca znacznika <Script>
HTML w kodzie Do tej pory przyglądaliśmy się przypadkom umieszczenia kodu w HTML-u, lecz możliwe są również sytuacje odwrotne. Możemy umieścić HTML w kodzie. Mógłbyś na przykład napisać kod, który powoduje wyświetlenie innego koloru tła w czasie dnia, a innego w nocy. Przykładem może tutaj być następujący kod: <TITLE>Change the Light 6 and Hour(Time) < 19 then Response.Write "" else Response.Write "" end if %> W nocy wyłączamy światło.
Zwróć uwagę na to, jak wygląda kod. Posiada jeden znacznik treści () dla godzin od 7 rano do 6 wieczorem oraz drugi dla pozostałej części dnia. Tak więc w nocy wynikiem bloku kodu będzie ten HTML:
Rysunek 4.4. pokazuje wygląd strony w nocy.
Rozdział 4 – Podstawy ASP
Rysunek 4.4. Strona zmieniająca kolor tła — w godzinach nocnych W czasie dnia wyjściowym znacznikiem treści kodu będzie:
Wygląd strony w tym wypadku pokazuje rysunek 4.5.
Rysunek 4.5. Strona zmieniająca kolor tła — w czasie dnia
102
ASP – Kompendium programisty
103
Skrypt w skrypcie Możesz również włączyć wynik twojego skryptu strony serwera do skryptu po stronie klienta, w ten sposób kod strony serwera zostanie uruchomiony i umieści tekst w kodzie po stronie klienta, który z kolei będzie rozpoznany przez przeglądarkę. Aby to zademonstrować, spróbujmy stworzyć kalkulator obliczający cenę, z którego klienci mogliby skorzystać w celu określenia, ile będzie kosztowała pewna ilość produktu. Stałym klientom oferujemy inną cenę niż pozostałym. Chcemy, aby cena była obliczana po stronie klienta w celu zredukowania liczby połączeń i aby szybkość działania kalkulatora pozwalała klientom na wielokrotne wpisywanie cen. Musimy jednak stworzyć skrypt po stronie klienta, aby cena była ustalana indywidualnie w oparciu o typ klienta, co z kolei zapisane jest w zmiennej po stronie serwera. Poniższy kod realizuje to zadanie, łącząc skrypt strony klienta i strony serwera: <TITLE>Client and Server <SCRIPT language="JavaScript"> * document.sampleform.Quantity.value; alert("Twoja cena wynosi $" + TheMessage); } // --> Wpisz ilość, aby określić cenę
Pierwszy blok kodu jest kodem ASP strony serwera napisanym w VBScripcie. Rozpoznajemy to po użytych znacznikach:
Kod sprawdza zmienną sesji, która została omówiona dalej, w rozdziale 8. W zmiennej TheRate kod ustawia odpowiednią wartość w oparciu o typ klienta (CustomerType). Następnie blok wstawia wynik kodu strony serwera w blok kodowy strony klienta. <SCRIPT language="JavaScript"> * document.sampleform.Quantity.value; alert("Twoja cena wynosi $" + TheMessage); } // -->
Znacznik Script bez zaznaczenia, że należy go uruchomić na serwerze, jest zinterpretowany jako kod strony klienta. Zauważ, że wewnątrz bloku kodu znajduje się kod ASP strony serwera:
Kod strony serwera jest uruchamiany przed wysłaniem bloku kodu do przeglądarki. Jeśli więc odwiedzający nie jest stałym klientem, jego przeglądarka otrzyma następujący HTML: <TITLE>Client and Server <SCRIPT language="JavaScript"> Wpisz ilość, aby określić cenę
Na wstępie powinieneś zauważyć, że brak jest pierwszego bloku kodu. Jest tak, ponieważ brakujący blok jest blokiem kodu strony serwera, a my teraz obserwujemy to, co jest wysyłane do klienta. Zauważ również, że
ASP – Kompendium programisty
105
zmienna TheRate w znacznikach skryptu została zastąpiona wartością 50, tak więc cały kod strony serwera zniknął, a przeglądarka otrzymała dostosowaną do klienta wersję procedury CheckPrice. Rysunek 4.6. pokazuje wygląd tej strony, a rysunek 4.7. przedstawia okno wiadomości prezentujące obliczoną cenę.
Rysunek 4.6. Strona kodu klienta i serwera
Rysunek 4.7. Okno pojawiające się po naciśnięciu przycisku Pokaż cenę Jeśli odwiedzający stronę jest stałym klientem, jego cena będzie ustalona na poziomie 25 $ za jednostkę produktu. Skrypt strony klienta będzie wtedy zawierał nieco inny wiersz kodu określającego cenę pojawiającą się w wiadomości: TheMessage = 25 * document.sampleform.Quantity.value
Dyrektywa przetwarzania Domyślnie ustawionym językiem kodu ASP w serwerze IIS jest VBScript. Możesz też wyraźnie stwierdzić, że będziesz używał VBScripta jako twojego kodu poprzez umieszczenie na górze strony następującej dyrektywy przetwarzania:
Zapamiętaj, że ten wiersz musi znaleźć się na stronie jako pierwszy. Informuje on kompilator o tym, że używanym w stronie językiem programowania będzie VBScript. Jeśli chcesz użyć języka JScript, dyrektywa będzie wyglądała następująco:
Rozdział 4 – Podstawy ASP
106
Pliki Include Po co ich używać W miarę jak twoja strona ASP będzie się rozbudowywała zobaczysz, że jej bloki kodu rozrastają się do bardzo dużych rozmiarów, a ty przez cały czas wpisujesz do nich te same procedury. Pliki Include pomagają radzić sobie z takimi problemami, dzięki nim można bowiem wstawić kod do pliku, a następnie wywołać ten kod w stronie ASP. Załóżmy na przykład, że posiadasz standardowe procedury zatwierdzania danych, które odwiedzający wprowadza do formularza na stronie. W formularzu może znajdować się sprawdzane w jakiś sposób pole daty, kilka pól, których wypełnienie jest wymagane oraz sprawdza się w nim liczby i ich zakres. Ten rodzaj kodu prawdopodobnie znalazłby zastosowanie w wielu stronach. Jeśli chciałbyś zmodyfikować działanie którejś z procedur, musiałbyś dokonać zmian na każdej ze stron, która z procedury korzysta. Lepiej więc umieścić kod zatwierdzania w osobnym pliku tekstowym, a następnie po prostu połączyć z plikiem te strony, które z niego korzystają. Pliki Include pomagają oczyścić nadmiernie rozbudowane strony, czyniąc je w ten sposób łatwiejszymi do uruchomienia. Jest tak, ponieważ kod jest położony w centralnym punkcie, przez co w prostszy sposób można go modyfikować. Kolejnym powodem umieszczania kodu w plikach Include jest ochrona programistów przed nadmierną złożonością kodu. Możesz mieć w firmie programistę, który jest ekspertem od obiektów danych współpracujących (CDO — Collaborative Data Objects). Obiekty CDO są używane do wysyłania poczty elektronicznej poprzez twoją stronę ASP oraz do współpracy z Microsoft Exchange. Taki programista może mieć klika skomplikowanych procedur zarządzającymi kalendarzami Exchange. Jeśli przekazał on swój kod innym pracownikom, aby go umieścili na swoich stronach ASP, istnieje ryzyko, że będą oni używali tego kodu w sposób niepoprawny, ponieważ mogą go nie rozumieć. Jeśli programista CDO umieściłby swój kod w pliku Include, inni pracownicy firmy nie musieliby rozumieć zawiłości kodu w nim zawartego. Mogliby po prostu włączyć w stronę plik CDO i wywoływać jego procedury. Włączanie pliku Aby włączyć plik w zawartość strony ASP, użyj po prostu znacznika Include: <SCRIPT LANGUAGE="vbscript" RUNAT="server">
W tym przykładzie plik Include musi być umieszczony w katalogu o nazwie Lib, który jest położony o jeden poziom wyżej niż bieżący katalog. Włączenie pliku powoduje efekt umieszczenia całego znajdującego się w nim kodu dokładnie w tym miejscu, gdzie pojawił się wiersz Include. Każdy wiersz włączonego pliku nie staje się jednak fizycznie częścią strony ASP.
ASP – Kompendium programisty
107 Plik Include — struktura i przykład
Plik Include jest prostym plikiem tekstowym zawierającym twój kod. Tak jak w przypadku każdej strony ASP, kod ma następującą strukturę:
