BETA
Aby się zalogować, najpiew wybierz portal.
Aby się zarejestrować, najpiew wybierz portal.
Podaj słowa kluczowe
Słowa kluczowe muszą mieć co najmniej 3 sąsiadujące znaki alfanumeryczne
Pole zawiera niedozwolone znaki

Baza wiedzy











Szablony

08-01-2005 23:20 | User 84105
Tematem artykułu są szablony. Postaram się w nim wyjaśnić czym one są, do czego służą, co nam dają i jak możemy je wykorzystać w praktyce. Zaprezentowane zostaną dwie przykładowe aplikacje, a tym samym dwa odmienne podejścia, pokazujące sposób wykorzystania oraz zalety i wady szablonów. Zapraszam do lektury.

Wstęp

 

Tematem artykułu są szablony. Postaram się w nim wyjaśnić czym one są, do czego służą, co nam dają i jak możemy je wykorzystać w praktyce. Zaprezentowane zostaną dwie przykładowe aplikacje, a tym samym dwa odmienne podejścia, pokazujące sposób wykorzystania oraz zalety i wady szablonów. Zapraszam do lektury.

 

Czym jest szablon?

 

Szablon można zdefiniować jako pewien wzorzec, który przechowuje informacje o sposobie prezentacji danych, nie zawierając ich w sobie. Dane te należy do szablonu dostarczyć. Aby jeszcze lepiej zrozumieć ideę szablonu spróbujmy spojrzeć na niego w następujący sposób:

Załóżmy, że szablonem jest kartka pocztowa, która posiada wcześniej przygotowane pola do wpisania adresu. Sama kartka nie zawiera żadnych danych, zawiera jednak specjalnie przygotowane miejsca do ich wpisania.

Identycznie sytuacja wygląda w przypadku naszych szablonów. Są one bowiem wzorcem opisującym sposób w jaki należy przedstawić przekazane do szablonu dane.

 

Do czego służy szablon?

 

Idea szablonów nie jest nowa. Pojawiła się w momencie, gdy konieczne było oddzielenie danych od sposobu ich prezentacji. Jest to główne zastosowanie szablonów. Znów możemy zapytać w jakim celu się to robi. Wyobraźmy sobie prostą sytuację:

W firmie pracują programiści oraz designerzy. Ci pierwsi zajmują się tworzeniem aplikacji WWW, ci drudzy projektują wygląd stron internetowych. Jak pogodzić ich pracę? Żaden programista nie chce, żeby designer projektując wygląd strony przez przypadek zmienił kod źródłowy pewnej aplikacji i odwrotnie. W dodatku dla jednych i drugich poruszanie się po dokumentach zawierających kod źródłowy razem z HTML-em jest utrudnione. Musimy zatem oddzielić dane od sposobu ich prezentacji. Wtedy programiści będą mogli swobodnie na nich operować, a wynikiem tych operacji będą dane zapisane w pewnym określonym formacie. Format ten musi być znany designerom. Oni bowiem zaprojektują wygląd strony i w odpowiednich fragmentach wyświetlą otrzymane dane.

Tak więc zastosowanie szablonów pozwala nam oddzielić dane od sposobu ich prezentacji. To jednak nie wszystkie zalety. Konsekwencją tego podziału (na dane i sposób ich prezentacji) jest fakt, iż jedne dane możemy w bardzo prosty sposób prezentować na wiele możliwych sposobów. Powiedzmy więcej. Zmiana sposobu prezentacji nie wiąże się ze zmianą wszystkich dokumentów, lecz tylko ze zmianą plików opisujących wygląd strony WWW. Zauważmy kolejne możliwości. Jeśli szablon odpowiada tylko za wygląd, a dane zawsze są w ustalonym formacie, to nie ma przeszkód by w łatwy sposób stworzyć nie tylko wiele wersji jednej strony internetowej, ale również wersje dla różnych przeglądarek, urządzeń. Możemy bowiem przygotować szablony, które zaprezentują dane w postaci dokumentów HTML, XHTML, WML, XML itd.

 

Wydawać by się mogło, że jest to rozwiązanie bez wad. Jednak i w tym przypadku za otrzymaną funkcjonalność zmuszeni jesteśmy zapłacić pewną cenę. Będzie nią czas bowiem wypełnienie szablonu danymi zajmie więcej czasu niż bezpośrednie wypisanie danych w odpowiednim formacie. Jednakże koszt ten nie wydaje się być wielki. Potwierdza to powszechność zastosowanego rozwiązania.

 

Zalety:

  • Dane odseparowane od sposobu prezentacji
  • Zmiana sposobu prezentacji nie pociąga za sobą konieczności modyfikacji danych i odwrotnie
  • W łatwy sposób możemy tworzyć nie tylko wiele wersji strony internetowej, ale również wersje dla różnych przeglądarek lub urządzeń

Wady:

  • Dłuższy czas generowania strony
  • Designerzy muszą poznać sposób tworzenia szablonów

Jak wygląda szablon?

Początkowo szablony były zwykłymi plikami tekstowymi zawierającymi specjalne znaczniki, które mówiły, iż w danym miejscu należy wprowadzić określoną wartość. Tak więc szablon mógł wyglądać np. tak:

 

<html>
  <head>
    <meta http-equiv="Content-type" content="text/html; charset={KODOWANIE}">
  <title>{TITLE}</title>
 
</head>
 
<body bgcolor="{BGCOLOR}">

    <p>{PARAGRAF}</p>

  </body>

</html>

 

W powyższym dokumencie widzimy trzy znaczniki:

  • KODOWANIE
  • TITLE
  • PARAGRAF

Zadaniem programisty było nadanie wartości zmiennym o takich nazwach jak nazwy znaczników. Ścieżka do szablonu oraz dane do wypełnienia szablonu były przekazywane do specjalnej funkcji, która zajmowała się parsowaniem szablonu i wypełnianiem znaczników danymi.

Powyższe rozwiązanie również posiada wady. Na programiście bowiem spoczywa konieczność napisania systemu do obsługi szablonów. W dodatku designer zmuszony jest zapoznać się ze znacznikami. Wystarczy tylko spojrzeć na różne systemy szablonowe takie jak np. Smarty dla PHP, by zapoznać się ze złożonością przedstawionego rozwiązania.

Istnieje jednak znacznie lepsze rozwiązanie. Wiemy bowiem, że do opisu danych świetnie nadaje się XML (EXtensible Markup Language). Co jednak z warstwą prezentacji? Również istnieje gotowe rozwiązanie – XSL (eXtensible Stylesheet Language). Arkusze XSL są dla dokumentów XML tym samym, czym są arkusze CSS dla dokumentów HTML. Jest jednak pewna różnica. Dokument HTML zostanie zinterpretowany przez przeglądarkę nawet gdy nie będzie posiadał arkusza CSS, ale dokument XML bez arkusza XSL już nie. XML jest bowiem językiem znaczników, które tworzymy sami. Przeglądarka nie wie w jaki sposób należy te znaczniki zinterpretować. Tym zajmuje się arkusz XSL.

Jednak i to rozwiązanie ma pewne wady. Wymaga ono bowiem wsparcia przeglądarki internetowej. Wiemy jednak, iż Internet Explorer 5.0 oraz 5.5 nie spełniają standardu, gdyż zostały stworzone w momencie, gdy standard XSLT (XSL Transformations) nie został jeszcze zdefiniowany przez W3C. Internet Explorer 6.0 jest już zgodny ze standardem. Sytuacja nie wygląda jednak najlepiej w przypadku innych przeglądarek. Netscape 6 również nie spełnia standardu, jednakże Netscape 7 już jest z nim zgodny. Tym bardziej nie możemy liczyć na wsparcie standardu ze strony przeglądarek urządzeń mobilnych.

Zatem w obecnej sytuacji, gdy nie możemy być pewni czy przeglądarka poradzi sobie z poprawnym wyświetleniem danych, jesteśmy niejako zmuszeni zastosować inne rozwiązanie. Możemy wykonać przekształcenie XSLT po stronie serwera, przeglądarka otrzyma jedynie wynik tego przekształcenia. Zazwyczaj jest nim dokument HTML, XHTML lub WML.

 

Do zrozumienia dalszej części artykułu wymagana jest wiedza o tworzeniu dokumentów XML i ich schematów, a także arkuszy XSL (patrz odnośniki).

 

Żeby zaprezentować możliwości szablonów oraz sposób ich wykorzystania stworzymy dwie aplikacje internetowe.

 

Statyczne pliki XML

 

Założenia aplikacji:

  • Aplikacja pobiera plik z danymi (dokument XML) na podstawie wartości parametru przekazanego metodą GET (a więc w pasku adresu).
  • Dokument XML posiada zdefiniowany schemat. Jeśli wczytany dokument jest niezgodny ze schematem zostaje wyświetlony komunikat.
  • Odpowiedni styl, a więc arkusz XSL jest wybierany na podstawie informacji zawartej w cookie.
  • Zarówno plik XML jak i arkusz XSL muszą znajdować się w odpowiednim katalogu, w przeciwnym przypadku zostaje wyświetlona strona główna z zastosowaniem domyślnego szablonu.
  • Chcemy dać użytkownikom możliwość łatwego drukowania specjalnej wersji strony – wtedy styl obowiązuje tylko dany dokument (nie jest wysyłany cookie – dotyczy stylu „print”).

 

Naszą pracę powinniśmy rozpocząć od zdefiniowania schematu dokumentu XML. Następnie tworzymy pliki XML zawierające odpowiednie dane oraz arkusze XSL służące do prezentacji danych w określony sposób.

 

Warto wspomnieć, że jeśli chcemy generować dokumenty XHTML w arkuszu XSL musimy umieścić następującą informację:

 

<xsl:output method="xml" encoding="iso-8859-2" doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" omit-xml-declaration="yes" media-type="text/html"/>

 

Zmuszeni jesteśmy wtedy ręcznie umieścić deklarację kodowania (meta) w tworzonym arkuszu XSL. Konieczna jest również zmiana kodowania danych wysyłanych przez aplikację. Możemy tego dokonać bezpośrednio w kodzie źródłowym:

[Kod C#]

Response.Charset = "iso-8859-2";
 

Bardzo często w arkuszach XSL chcemy wykorzystać pewne zmienne. Możemy tego dokonać deklarując w arkuszu obecność zmiennej:

<xsl:variable name=”parametr”/>

Następnie w naszej aplikacji tworzymy listę argumentów:

[Kod C#]

XsltArgumentList argList = new XsltArgumentList ();

argList.AddParam ("parametr", "", "wartosc");

i przekazujemy ją do przekształcenia XSLT:

[Kod C#]

XslTransform xslt = new XslTransform ();

xslt.Load (sciezka_do_arkusza_xsl);

 

xslt.Transform (xmlDoc, argList, Response.OutputStream, resolver);

 

Wynik przekształcenia jest wysyłany bezpośrednio do przeglądarki.

Resolver jest niezbędny zawsze wtedy, gdy w arkuszu XSL odwołujemy się do zewnętrznych dokumentów poprzez document(‘nazwa.xml’).

 

Jego stworzenie jest bardzo proste:

[Kod C#]

XmlUrlResolver resolver = new XmlUrlResolver ();

 

Dokument XML wczytujemy w następujący sposób:

[Kod C#]

XmlDocument xmlDoc = new XmlDocument();

xmlDoc.Load (sciezka_do_dokumentu_xsl);

 

Na każdej z podstron witryny internetowej użytkownik ma możliwość zmiany stylu graficznego. Odnośniki są generowane dynamicznie na podstawie zawartości katalogu przechowującego arkusze XSL.

Przyjrzyjmy się odpowiedniej metodzie:

[Kod C#]

private void appendStyles (XmlDocument xmlDoc)

{

  String dirPath = Path.GetDirectoryName (this.Request.PhysicalPath); // aktualna ścieżka

  String [] files = Directory.GetFiles (Path.GetDirectoryName(dirPath + xsl)); // lista plików w katalogu XSL

  XmlElement elem = xmlDoc.CreateElement ("styles"); // utwórz nowy węzeł

  xmlDoc.DocumentElement.AppendChild (elem); // dodaj go do drzewa XML

  foreach (String file in files) // dla każdego pliku z katalogu XSL

  {

    XmlElement son = xmlDoc.CreateElement ("style"); // utwórz węzeł

    son.InnerText = Path.GetFileNameWithoutExtension(file); // zapisz nazwę pliku (bez rozszerzenia)

    elem.AppendChild (son); // dodaj węzeł do "styles"

  }

}

 

Bardzo łatwo możemy dodawać do istniejącego drzewa XML nowe węzły. Tak jest również w powyższym przykładzie. Dodajemy bowiem węzły zawierające informacje o dostępnych stylach.

 

By upewnić się, że wczytany dokument XML jest zgodny ze schematem, przed każdym wykonaniem przekształcenia XSLT sprawdzana jest owa zgodność. Do tego celu został wykorzystany obiekt klasy XmlValidatingReader:

[Kod C#]

// wywoływana w tylko wtedy, gdy dokument XML jest niezgodny ze schematem

private void validationError (object sender, ValidationEventArgs args)

{

  this.isValid = false; // plik XML jest niepoprawny!

  error += args.Message; // dodaj komunikat o błędzie

}

 

public bool validate ()

{

  XmlTextReader reader = null;

  XmlValidatingReader validReader = null;

  XmlSchemaCollection schemaCollection = null;

  XmlTextReader schemaReader = null;

  try

  {

    try

    {

      schemaCollection = new XmlSchemaCollection (); // kolekcja schmatów

      schemaReader = new XmlTextReader (this.xsdPath);

      XmlSchema schema = XmlSchema.Read (schemaReader, new ValidationEventHandler(compileError)); //wczytujemy schemat

      schemaCollection.Add (schema); // dodajemy schemat do kolekcji

      schemaReader.Close();

    }

    catch (XmlSchemaException e)

    {

      schemaReader.Close();

      return false;

    }

 

    reader = new XmlTextReader (this.xmlPath); // wczytaj plik XML

    validReader = new XmlValidatingReader (reader);

    validReader.Schemas.Add (schemaCollection); // dodajemy kolekcję schamatów do sprawdzenia

    validReader.ValidationEventHandler += new ValidationEventHandler (validationError);

    while (validReader.Read());

    validReader.Close();

    reader.Close();

    if (isValid) return true;

    return false;

  }

  catch (Exception e)

  {

    validReader.Close();

    reader.Close();

  }

  return false;

}

 

W przedstawionej aplikacji wyboru pliku XML dokonujemy na podstawie parametru przesłanego metodą GET. Listę tych parametrów możemy przeglądać w następujący sposób:

[Kod C#]

NameValueCollection paramList = Request.QueryString; // lista parametrów

String [] names = paramList.AllKeys;

 

for (int i = 0 ; i < names.Length ; i++)

{

  if (names[i].Equals (”nazwa parametru”))

  {

    String [] valuesList = paramList.GetValues (i); // lista wartości dla danego parametru

// tutaj dodatkowe operacje

  }

}

 

Widzimy zatem, że sam kod źródłowy jest bardzo prosty. Najtrudniejszym zadaniem jest przygotowanie schematu, plików XML oraz arkuszy XSL. Siła tego rozwiązania tkwi w sile przekształcenia XSLT i ma kilka istotnych zalet:

  • Programista nie musi sam tworzyć systemu parsowania szablonów – wiąże jedynie dane zawarte w pliku XML z odpowiednim arkuszem XSL i wykonuje przekształcenie XSLT po stronie serwera.
  • Składnia arkuszy XSL jest ściśle określona przez standard W3C.
  • Schemat ściśle określa postać dokumentów XML.

Po zapoznaniu się z przykładem możemy stwierdzić, iż udało nam się stworzyć prosty system szablonów. W pliku menu.xml przechowywane jest globalne menu wyświetlane na każdej ze stron. W dodatku każdy dokument może posiadać własne, lokalne menu (zarówno z odnośnikami wewnętrznymi jak i zewnętrznymi). Odpowiednio przygotowane arkusze XSL pozwalają na proste formatowanie zawartości bloków. Nic nie stoi jednak na przeszkodzie by umożliwić znacznie bardziej zaawansowane formatowanie.

 

Decydując się na przedstawiony w aplikacji sposób wybierania dokumentów musimy pamiętać o kilku zasadach:

  • Nigdy nie możemy ufać danym pochodzącym od użytkownika. Łatwo bowiem zmodyfikować adres i przesłać nową, nieoczekiwaną wartość parametru. W naszym przykładzie odczytujemy plik XML o nazwie, która zostanie przesłana jako parametr metodą GET. Musimy zatem zabezpieczyć się przed sytuacją, w której użytkownik próbuje czytać dane poza określonym katalogiem. Musimy również sprawdzić czy podany plik istnieje.
  • Domyślnie podczas startu aplikacji wywoływana jest metoda ValidateInput(), która rzuca wyjątek HttpRequestValidationException w przypadku, gdy dane przesłane przez użytkownika są potencjalnie niebezpieczne. Sprawdzane są zarówno parametry przesłane metodą GET jak i POST, a także zawartość cookies. Niebezpieczeństwo jest zatem eliminowane niejako automatycznie. Musimy jednak tę sytuację wyjątkową obsłużyć.

W tym celu w pliku Global.asax.cs zmieniamy metodę Application_Error:

[Kod C#]

protected void Application_Error(Object sender, EventArgs e)

{

  System.Exception ex = Server.GetLastError();

 

  if(ex.GetBaseException() is System.Web.HttpRequestValidationException )

  {

    Response.Redirect ("error.html"); // gdy dane są potencjalnie niebezpieczne przekieruj użytkownika na stronę z informacją o błędzie

  }

}

 

W przykładowej aplikacji została umieszczona metoda odpowiedzialna za przypisanie odpowiedniego stylu w zależności od używanej przeglądarki. Przykład ten ma pokazać, iż możemy w prosty sposób prezentować dane w formacie dostosowanym do danej przeglądarki. Bardzo często spotykamy się z różnicami w interpretacji kodu HTML lub arkuszy CSS. W ten prosty sposób możemy dostosować wygląd naszej witryny do każdej przeglądarki. Jak więc widzimy szablony nie służą tylko do zmiany szaty graficznej witryny (jak ma to miejsce w zaprezentowanym przykładzie). Tę funkcjonalność można osiągnąć również w inny sposób (np. poprzez zmianę tylko i wyłącznie arkusza CSS). Wyobraźmy sobie natomiast inną sytuację:

Posiadamy witrynę, na której nasze menu znajduje się po lewej stronie. Witryna ulega jednak rozbudowaniu i musimy przenieść owe menu na prawą stronę. W takim przypadku modyfikacja ograniczy się tylko i wyłącznie do zmiany arkusza XSL. Pójdźmy jednak dalej. Co jeśli zechcemy przygotować wersję naszej witryny dla telefonów komórkowych? Wystarczy dodać nowy arkusz XSL przekształcający dane do dokumentu WML oraz przekierować przeglądarkę na dany styl (ten, który określa wygląd dokumentu WML). Szczególnie w takich sytuacjach szablony pokazują swoją siłę i przydatność.

 

Dynamicznie generowane pliki XML

W praktyce jednak znacznie częściej mamy do czynienia z danymi, które są generowane dynamicznie lub znajdują się w bazie danych. Czy wtedy nie możemy już korzystać z szablonów? Odpowiedzi udziela druga aplikacja.

 

Spróbujemy zbudować księgę gości, która będzie spełniać następujące założenia:

  • Wszystkie dane znajdują się w bazie danych, którą na potrzeby tego artykułu jest SQL Server.
  • Sposób prezentacji danych zawarty jest w arkuszach XSL.
  • Korzystamy z różnych arkuszy XSL dla danego stylu (styl jest nazwą katalogu z arkuszami XSL).
  • Użytkownik może dodawać nowe wpisy.
  • Niepoprawne dane podane w formularzu są zwracane do użytkownika z określeniem niepoprawnych pól.
  • Wpisy zgromadzone w bazie danych są wyświetlane z podziałem na strony.
  • Na stronie głównej wyświetlamy jedynie 255 pierwszych znaków komentarza oraz umieszczamy odnośnik do strony z pełną treścią komentarza.
  • Zapewniamy anonimowość użytkowników, nie wyświetlamy pełnego IP (xxx.yyy.zzz.*).

Przystępując do tego zadania powinniśmy rozpocząć od stworzenia schematów dokumentów XML. W zaprezentowanym przykładzie stworzono cztery schematy (wyświetlanie wszystkich wpisów - index, wyświetlanie pojedynczego wpisu - single, dodawanie wpisu (formularz) - add, komunikat o wprowadzeniu danych - inserted). W katalogu XSL powinniśmy utworzyć nowy katalog o nazwie stylu i w nim umieścić arkusze XSL o nazwach takich samych jak nazwy schematów.

 

Aby dane z formularza posiadały polskie znaki musimy zmienić kodowanie. Aby tego dokonać w pliku web.config w znaczniku globalization zmieniamy kodowanie na „ISO-8859-2” (zarówno dla request jak i response).

 

Dane pochodzące z bazy danych mają formę tabel o stałej liczbie kolumn i zmiennej liczbie wierszy. Dzięki temu możemy łatwo wygenerować dokument XML na podstawie dowolnego zapytania do bazy danych:

[Kod C#]

public XmlDocument generateXmlFromSQLQuery (String connectionString, String sqlQuery)

{

  XmlDocument xmlDoc = new XmlDocument (); // utwórz nowy dokument XML

 

  SqlConnection conn = new SqlConnection (connectionString); // połączenie

  SqlCommand cmd = new SqlCommand (sqlQuery, conn);

  conn.Open (); // otwórz połączenie

  SqlDataReader reader = cmd.ExecuteReader (CommandBehavior.CloseConnection); // wykonaj zapytanie

 

  XmlElement root = xmlDoc.CreateElement ("", "guestbook", ""); // utwórz nowy węzeł "guestbook"

  xmlDoc.AppendChild (root); // dodaj go do drzewa XML

 

  try

  {

    while (reader.Read())

    {

      XmlElement row = xmlDoc.CreateElement ("", "row", "");

                             root.AppendChild (row);

 

      for (int i = 0 ; i < reader.FieldCount ; i++) // dla każdej kolumny wyniku zapytania

      {

        XmlElement elem = xmlDoc.CreateElement ("", reader.GetName (i).ToString(), ""); // utwórz węzeł o nazwie kolumny

        elem.InnerText = reader.GetValue (i).ToString(); // wypełnij go zawartością

        row.AppendChild (elem); // dodaj węzeł do "row"

      }

    }

  }

  finally

  {

    reader.Close();

  }

 

  return xmlDoc;

}

 

Zaprezentowana powyżej metoda zwróci nam referencję do instancji obiektu XmlDocument przechowującej drzewo XML będące odpowiedzią na zapytanie. Wykonanie tej metody spowoduje wygenerowanie drzewa XML o następującej strukturze:

 

<guestbook>

    <row>

        <nazwa_kolumny>zawartość_kolumny</nazwa_kolumny>

                                        

    </row>

</guestbook>

 

Tak więc zarówno do stworzenia schematu jak i arkusza XSL musimy znać jedynie strukturę tabeli. W przykładzie wygląda ona następująco:

 

 

W przypadku pola id musimy jeszcze zaznaczyć:

 

 

Dzięki temu każdy wprowadzony rekord zostanie oznaczony kolejnym, unikalnym numerem jednoznacznie identyfikującym wprowadzone dane.

Omówmy jeszcze strukturę tabeli:

 

id - identyfikator wpisu

user - imię i nazwisko

email - adres e-mail

website - adres www

content - treść komentarza

created - data w formacie YYYY.MM.DD hh:mm:ss

ip - adres IP

 

Tylko pola user, email, website oraz content są wypełniane przez użytkownika. Pole id jest nadawane przez bazę danych, pola created i ip przez aplikację.

 

Sprawdzenia poprawności wygenerowanego na podstawie zapytania drzewa XML dokonujemy w identyczny sposób jak w poprzednim przykładzie. Jednakże nie wczytujemy pliku XML z dysku, lecz przekazujemy go bezpośrednio (tutaj jako xmlDoc ):

[Kod C#]

NameTable nt = new NameTable();

XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);

                       

XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

 

validReader = new XmlValidatingReader (xmlDoc.OuterXml, XmlNodeType.Element, context);

 

Przy danych generowanych na podstawie zapytania SQL często zachodzi konieczność ręcznej ich modyfikacji. Możemy tego bardzo prosto dokonać. Zapoznajmy się z przykładem, który modyfikuje adresy IP:

[Kod C#]

private void changeIP (XmlDocument xmlDoc)

{

  XmlNodeList nodeList = xmlDoc.GetElementsByTagName ("ip", ""); // znajdź węzły "ip"

  for (int i = 0 ; i < nodeList.Count ; i++) // dla każdego węzła

  {

    String ip = nodeList[i].InnerText;

    nodeList[i].InnerText = ip.Substring (0, ip.LastIndexOf (".") + 1) + "*"; // zmień IP

  }

}

 

W ten oto łatwy sposób możemy modyfikować dowolny węzeł drzewa XML będącego rezultatem zapytania SQL.

 

Treść zapytań SQL jest generowana dynamicznie na podstawie otrzymanych parametrów.

 

Jednym z napotkanych problemów może być wykonanie stronicowania, ponieważ w SQL Server nie istnieje odpowiednik LIMIT-a znanego z innych baz danych. Nie możemy również wybierać rekordów, których id jest w danym zakresie, zakładamy bowiem, że administrator księgi może usuwać wpisy. Konsekwencją tego działania będą luki w numerowaniu. Bardzo łatwo można jednak sobie z tym problemem poradzić. Możemy zadać zapytanie o treści:

[Kod SQL]

SELECT TOP 5 * FROM table_name;

 

Zwróci ono pięć pierwszych rekordów z tabeli table_name. Wykorzystując podzapytania możemy osiągnąć funkcjonalność LIMIT-a:

[Kod SQL]

SELECT * FROM (

SELECT TOP 5 * FROM (

SELECT TOP 10 * FROM table_name ORDER BY pole DESC) AS a

ORDER BY pole ASC) AS b

ORDER BY pole DESC;

 

W ten sposób otrzymamy wynik zapytania posortowany wg. kolumny „pole” malejąco. Niezwykle istotna jest tutaj zmiana trybu sortowania na przeciwny (z malejącego na rosnący) w pierwszym podzapytaniu.

 

Jeśli którykolwiek z parametrów przesłanych przez użytkownika jest niepoprawny budujemy nowe drzewo XML zawierające te dane (przesłane przez użytkownika) i poddajemy je przekształceniu XSLT podając arkusz XSL odpowiedzialny za wyświetlenie formularza. W ten sposób możemy wypełnić formularz poprzednio wprowadzonymi danymi i zasygnalizować użytkownikowi miejsca, w których istnieją błędy.

 

Do pełnej funkcjonalności księdze gości brakuje panelu administracyjnego z możliwością usuwania/edytowania wybranych wpisów.

 

Podsumowanie

Na podstawie zaprezentowanych przykładów możemy zaobserwować, iż szablony są bardzo ciekawym mechanizmem dającym wiele korzyści. Przedstawione podejście jest proste do zaimplementowania i zwalnia programistę z konieczności budowy systemu obsługi szablonów. Wydaje się być słuszne również z innego powodu. Coraz częściej bowiem XML jest wykorzystywany jako warstwa pośrednia pomiędzy bazą danych a gotowym dokumentem wyjściowym.

Tak jak inne rozwiązania, tak i to, zaprezentowane przeze mnie, nie jest pozbawione wad. Wraz ze wzrostem złożoności dokumentów XML oraz arkuszy XSL wydłuża się czas trwania przekształcenia XSLT, a więc czas generowania strony. Sam więc osądź czytelniku czy warto korzystać z szablonów :)

 

Odnośniki

http://www.w3schools.com/ - HTML, XHTML, XML, XSL, XSLT, XPATH, XML Schema, WML i więcej

http://www.w3c.org/ - jw.

http://www.altova.com/support_freexmlspyhome.asp - przydatne narzędzie przy pracy z dokumentami XML, XSLT, XSD oraz innymi

http://msdn.microsoft.com/ - MSDN

http://smarty.php.net/ - system szablonów w PHP

Załączniki:

Podobne artykuły

Komentarze 0

pkt.

Zaloguj się lub Zarejestruj się aby wykonać tę czynność.