Aplikacje WEB

1. Technologie programowania aplikacji WEB

• dynamiczne generowanie treści stron WWW,
• proste, bezpośrednie przetwarzanie zleceń klienckich,
• kontrolowanie komunikacji z klientami - statystyki, zabezpieczenia, odtwarzanie informacji (sesje, cookies),
• dostarczanie informacji z baz danych,
• pośredniczenie pomiędzy programami klienckimi, a systemami informacyjnymi firmy w wykonywaniu zadań z zakresu złożonej logiki biznesowej.

• dostarcza wyspecjalizowanych technologii tworzenia tzw. web-komponentów, czyli komponentów, które obsługują zlecenia, a w szczególności potrafią reagować na nie dynamiczną generacją treści,
• implementuje koncepcje programowania kompnentowego (JavaBeans), co sprzyja nie tylko prostocie tworzenia aplikacji (np. w środowiskach programistycznych), ale również, czy może przede wszystkim, elastycznemu separowaniu treści i prezentacji,
• zapewnia uniwersalny, spójny z innymi środkami języka, mechanizm dostępu do baz danych (JDBC),
• wzmacnia to wszystko bogactwem standardowych pakietów Javy, które -  oczywiście - możemy wykorzystywać na poziomie apliakacji WEB.

2. Wdrażanie i uruchamianie aplikacji WEB

• stworzeniu pliku tzw. deskryptora wdrożenia (web deployment descriptor) o nazwie web.xml,
• ew. stworzenie dodatkowych specjalnych  plików opisowych (np. dla bibliotek znaczników JSP),
• umiejscowienie wszystkich komponentów aplikacji (klas, stron HTML, stron JSP, plików graficznych i dźwiękowych) oraz pliku deskryptora wdrożenia w odpowiedniej, ściśle określonej, strukturze katalogowej,
• dostarczenie serwerowi  ścieżki kontekstu aplikacji (context-path).

• plik deskryptora wdrożenia (web.xml) - koniecznie!
• pliki deskryptorów znaczników bobliotek JSP (z rozszerzeniem *.tld) - o ile stosujemy biblioteki znaczników,
• plik konfiguracji Java Server Faces (faces-config.xml) - o ile stosujemy JSF,
• podkatalog lib (5), zawierający dzielone biblioteki (pakiety) Javy w postaci plików JAR - jeśli tylko nasze klasy tego wymagają ,
• podkatalog classes (4), który zawiera skompilowane klasy Javy (m.in. serwlety, ale również inne); jeżeli klasy należą do nazwanych pakietów, to muszą być umieszczane w odpowiednich podkatalogach katalogu class.

• skopiowanie tej struktury do katalogu okreslanego przez właściwość appbase konfiguracji serwera; standardowo-  katalogu webapps, znajdującym się w katalogu instalacyjnym Tomcata - ścieżką kontekstu dla schematu z rysunku będzie wtedy /MojaAp (lub - jeśli nie kopiujemy całego katalogu MojaAp, lecz tworzymy  w webapps katalog o innej nazwie i kopiujemy do niego całą zawartość katalogu MojaAp - nazwa nowoutworzonego katalogu poprzedzona ukośnikiem).
• spakowanie tej struktury do archiwum o nazwie, mającej rozszerzenie WAR (od Web Application Archive) i skopiowaniu tego WAR-a do katalogu webapps - ścieżką kontekstu dla schematu z rysunku będzie /MojaAp,
• utworzenie deskryptora kontekstu aplikacji, w którym m.in podajemy odwzorowanie pomiędzy ścieżką kontekstu a katalogiem aplikacji; deskryptor ten można wpisac do pliku konfiguracyjnego serwera conf/server.xml, albo stworzyć go w odrębnym pliku XML o dowolnej nazwie i  umieścić ten plik w  katalogu webapps -  wtedy ścieżka kontekstu będzie pobrana z deskryptora kontekstu.

• definicje filtrów (dodatkowo przetwarzających, filtrującyhc, zlecenia dla serwletów i ich odpowiedzi)
• definicje słuchaczy (obsługujących zdarzenia związane z kontekstem i sesją),
• definicje serwletów (i ich parametrów inicjalnych) lub stron JSP składających się na aplikację oraz tzw. ich mapowanie, 
• konfiguracja sesji (czyli połączenia lub takich sekwencji połączeń użykownika z aplikacją, które zachowują tożsamość użytkownika)
• parametry kontekstu (dostępne dla wszystkich komponentów aplikacji),
• mapowanie typów MIME.
• strony powitalne,
• strony opisu błędów,
• lokalizacj deskryptorów bibliotek znaczników JSP (plików *.TLD)
• ograniczenia ze względu na bezpieczeństwo.
• definicje odniesień do zasobów (np. baz danych),

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-app_2_4.xsd">
   ...
   ...  inne elementy 
   ...
</web-app>

• gdy w głównym katalogu wdrożonej aplikacji znajduje się plik index.jsp, to zostanie on wywołany (ale to zależy od serwera i jego ustawień),
• gdy w pliku web.xml zdefiniowano listę plików powitalnych w następującej postaci

   <welcome-file-list>
     <welcome-file>plik1.jsp</welcome-file>
     <welcome-file>plik2.jsp</welcome-file>
     ...
   </welcome-file-list>

a w głównym katalogu aplikacji znajdują się któreś z tych plików, to zostanie wywołany pierwszy z listy, który jest w katalogu (jest to również sposób na dostarczenie użytkownikowi zwykłego pliku html, z którego albo mogą prowadzić linki do róznych części aplikacji, albo można dostarczyć form logowania, albo może on informować użytkownika, że zapomniał dodać do adresu zlecenia dodatkowej specyfikacji, np. zmapowanej nazwy serwletu i przez to nie może uruchomić aplikacji),

•  gdy mapowanie nazwy serwletu ma postać /*, oznaczającą dowolną nazwę, to zostanie wywołany serwlet, którego nazwa została w pliku web.xml przyporządkowana tej formie odwołania.

<?xml version="1.0"?>
<web-app version="2.4"
     xmlns="http://java.sun.com/xml/ns/j2ee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

   <display-name>Sklep ogrodniczy</display-name>

   <welcome-file-list>
     <welcome-file>run.jsp</welcome-file>
   </welcome-file-list>

</web-app>

• aby być serwletem HTTP, klasa musi odziedziczyć klasę HTTPServlet,
• przedefiniowana metoda doGet(HTTPServletRequest zlecenie, HTTPServletResponse odpowiedz) obsługuje zlecania GET (czyli np. "idące" z  paska adresów przeglądarki),
• odpowiedź generujemy w postaci strony HTML (lub zwyklego tekstu), pisząc go do strumienia związanego z obiektem HTTPServletResponse; w szczególności możemy wykorzystać strumień PrintWriter.

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class Msg extends HttpServlet {

  // Początek HTML i właściwości <body> - tło, kolor tekstu i linków
  private String prolog =
                 "<html><title>Przykład</title>" +
                 "<body background=\"images/os2.jpg\" text=\"antiquewhite\"" +
                 "link=\"white\" vlink=\"white\">";

  // Tagi zamykające
  private String epilog = "</body></html>";


  // Metoda obsługi zlecenia GET

  public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
                 throws ServletException, IOException
  {
     // Możemy w ten sposób ustalić typ treści i stronę kodową
     // łatwiej niż przez generowanie metatagów HTML

     response.setContentType("text/html; charset=ISO-8859-2");

     // Strumień wyjściowy, tu generowana treść strony HTML
     // PrintWriter umożliwia użycie metod print i println

     PrintWriter out = response.getWriter();


     out.println(prolog);  // piszemy początek html i tag <body ... >

     // Piszemy treść
     out.println("<h1>Dokument HTML<br>wygenerowany przez serwlet</h1>");
     out.println("<br><br><a href=\"Bye.html\">Pożegnanie</a>");

     // Znaczniki zamykające
     out.println(epilog);
     out.close();
  }

}

• nazwa identyfikująca serwlet.
• nazwa klasy serwletu,
• mapowanie nazwy sewrletu na nazwę, której użyje klient w specyfikacji URL zlecenia GET.

    <servlet>
       <servlet-name>HTMLMsg</servlet-name>
       <description>Prosty napis</description>
       <servlet-class>Msg</servlet-class>
    </servlet>

• dla celów identyfikacyjnych nazwaliśmy nasz serwlet HTMLMsg (inaczej niż nazwa klasy),
• możemy podać (choć niekoniecznie) krótki opis serwletu w  znacznikach <description>
• nazwę klasy serwletu podajemy w znacznikach <servlet-class>; nasza klasa Msg, zawarta w pliku Msg.java została skompilowana do pliku Msg.class - podaliśmy zatem nazwę klasy Msg
• i - uwaga - gdy serwlet jest w nazwanym pakiecie (a zatem i w podkatalogu katalogu classes) podajemy też nazwę pakietu np. controller.Msg

    <servlet-mapping>
        <servlet-name>HTMLMsg</servlet-name>
        <url-pattern>/msg</url-pattern>
    </servlet-mapping>

• element servlet musi poprzedzać element servlet-mapping,
• dla danego serwletu  jego nazwy w tagu <servlet-name> w obu elmentach muszą byc takie same,
• element url-pattern określa sposób odwołania do tego serwletu (być może jednego z wielu w ramach aplikacji); używając przy tym gwiazdek możemy dostarczyć wielu sposobów wywołania serwletu (np. podanie  /*.html będzie powodować wywołanie serwletu w sytuacji gdy użytkownik wprowadzi dowolną nazwę, zakończoną .html

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <display-name>Serwlety 1</display-name>
    <description>Proste przykladowe serwlety</description>

    <servlet>
       <servlet-name>HTMLMsg</servlet-name>
       <description>Prosty serwlet</description>
       <servlet-class>Msg</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HTMLMsg</servlet-name>
        <url-pattern>/msg</url-pattern>
    </servlet-mapping>

</web-app>

• nie wymaga kopiowania katalogów lub WARów,
• można za jego pomocą ustalić dowolną (ale jednoznaczną) nazwę kontekstu i związać ją z dowolnym fizycznym katalogiem, w którym rezyduje nasza apliakacja/
  

<Context  path="/Show"  docBase="G:/Programy/serwlety1/build">
</Context>

<Context  path="/wa1"   docBase="../../WebAplikacja1">
</Context>

• jaki jest URL zlecenia (metoda getRequestURL()),
• jaka jest ścieżka kontekstu - metoda getContextPath(),
• jaka jest ścieżka uruchamiająca serwlet, który po raz pierwszy otrzymał to zlecenie - metoda getServletPath().

• informacji o serwerze (getServerInfo()),
• nazwy aplilkacji podanej w omawianiym wcześniej tagu <display-name> pliku web.xml - metoda getServletContextName(),
• jaka jest prawdziwa (np. po części fizyczna w systemie plikowym hosta) ścieżka dla podanej ścieżki "wirtualnej" (takiej jak np. /serwlety1) - metoda getRealPath(String),
• jakie komponenty (i zasoby) składają się na aplikacje (metoda  getResourcePaths(String))

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.net.*;

public class Msg2 extends HttpServlet {

  private ServletContext context;
  private PrintWriter out;

  public void doGet(HttpServletRequest req, HttpServletResponse resp)
                       throws ServletException, IOException
  {
    out = resp.getWriter();
    out.println("To jest strona wygenerowana przez serwlet " +
                 this.getClass().getName()+ ".class");
    out.println("-------------------------------------------------------");

    // Jak wygladal URL z ktorego przyszlo zlecenie
    String requestURL = req.getRequestURL().toString();
    out.println("RequestURL: " + requestURL);

    // Uzyskujemy kontekst
    context = this.getServletContext();

    // Możemy od niego pobrać informacje o serwerze
    out.println("\nServer info\n" + context.getServerInfo() );

    // Możemy dowiedzieć się jaka jest nazwa aplikacji
    // określona w <display-name>
    out.println("\nAplikacja ma nazwe: " + context.getServletContextName() );

    // Informacje o ścieżkach
    String contextPath = req.getContextPath();
    String servletPath = req.getServletPath();

    // Od kontekstu możemy dowiedzieć się też jakie są fizyczne ścieżki
    // prowadzace do "wirtualnych" URLI
    out.println("\nInformacja o sciezkach");
    msg("ContextPath", contextPath);
    msg("ServletPath", servletPath);

    // I nasze pliki "zasobowe" (HTML, JPG)
    msg("Plik Bye.html", "Bye.html");
    msg("Plik os2.jpg", "images/os2.jpg");

    // Lista zasobów aplikacji
    out.println("\nLista zasobow aplikacji");
    listResources("/");

    // Możemy na tych zasobach wykonywać op we-wy
    InputStream in = context.getResourceAsStream("/WEB-INF/web.xml");
    BufferedReader br = new BufferedReader( new InputStreamReader(in));
    out.println("\nPierwszy wiersz pliku web.xml");
    out.println(br.readLine());
    br.close();

    // W jakim katalogu działa serwlet?
    File dir = new File(".");
    out.println("\nA serwlet dzialal w katalogu: " + dir.getAbsolutePath());


    out.close();
  }

   // Listuje zasoby aplikacji
  private void listResources(String path)  {
    if (path == null) return;
    Set res = context.getResourcePaths(path);
    for (Iterator iter = res.iterator(); iter.hasNext(); ) {
      String resItem = (String) iter.next();
      if (resItem.endsWith("/")) listResources(resItem);
      else out.println(resItem);
    }
  }

  private void msg(String info, String path) {
    out.println("------------------------------------------");
    out.println(info);
    String realPath = context.getRealPath(path);
    out.println("Virtual: " + path);
    out.println("Real   : " + realPath);
  }

}

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <display-name>Serwlety 1</display-name>
    <description>Proste przykladowe serwlety</description>

    <servlet>
       <servlet-name>HTMLMsg</servlet-name>
       <description>Prosty serwlet</description>
       <servlet-class>Msg</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HTMLMsg</servlet-name>
        <url-pattern>/msg</url-pattern>
    </servlet-mapping>

    <servlet>
       <servlet-name>Msg2</servlet-name>
       <description>Info o sciezkach</description>
       <servlet-class>Msg2</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Msg2</servlet-name>
        <url-pattern>/paths</url-pattern>
    </servlet-mapping>

</web-app<

To jest strona wygenerowana przez serwlet Msg2.class
-------------------------------------------------------
RequestURL: http://localhost:8080/serwlety1/paths

Server info
Apache Tomcat/6.0.13

Aplikacja ma nazwe: Serwlety 1

Informacja o sciezkach
------------------------------------------
ContextPath
Virtual: /serwlety1
Real   : E:\Serwery\apache-tomcat-6.0.13\webapps\serwlety1\serwlety1
------------------------------------------
ServletPath
Virtual: /paths
Real   : E:\Serwery\apache-tomcat-6.0.13\webapps\serwlety1\paths
------------------------------------------
Plik Bye.html
Virtual: Bye.html
Real   : E:\Serwery\apache-tomcat-6.0.13\webapps\serwlety1\Bye.html
------------------------------------------
Plik os2.jpg
Virtual: images/os2.jpg
Real   : E:\Serwery\apache-tomcat-6.0.13\webapps\serwlety1\images\os2.jpg

Lista zasobow aplikacji
/Bye.html
/images/os2.jpg
/WEB-INF/classes/Msg.class
/WEB-INF/classes/Msg2.class
/WEB-INF/web.xml

Pierwszy wiersz pliku web.xml
<?xml version="1.0" encoding="UTF-8"?>

A serwlet dzialal w katalogu: E:\Serwery\apache-tomcat-6.0.13\bin\.

3. Budowanie, rozwijanie i wdrażanie aplikacji za pomocą Ant-a.

• tworzenie niezbędnych katalogów,
• kompilację kodów źródłowych,
• kopiowanie plików do odpowiedniej struktury katalogowej,
• instalację lub wdrożenie aplikacji za pomocą specyficznych zadań, kierowanyh do managera aplikacji Tomacta.

• <katalog_aplikacji>
•      src      <--- podkatalog z kodami żródłowymi
•      web    <--- podkatalog z komponentami WEB (np. strony powitalne itp, opisy znaczników.)
•          WEB-INF  <--- w tym podkatalogi umieścimy deskryptor  wdrożenia web.xml  
• build.xml     <--- to będzie zapis działań dla Anta
• build.properties <--- ew. definicje różnych własciwości danej aplikacji
  
• context.xml  <--- opcjonalny plik deskryptora kontekstu aplikacji.
  

<project name="nazwa projektu" default="build" basedir=".">
  <target name="init">
      <tstamp/>
  </target>

• default - oznacza domyślne zadanie, gdy anta wywołamy bez argumentów (jako argument możemy podać zadanie do wykonania),
• basedir - oznacza katalog (tu bieżący) wobec którego "rozwiązywane" są relatywne odniesienia do katalogów i plików

app=serwlety1
app.path=E:/webaps/SERWLETY

  <property file="build.properties"/>
  <property name="build" value="${app.path}/${app}/build" />
  <property name="context.path" value="${app}" />

  <target name="prepare" depends="init"
   	description="Buduje katalogi build">
    <mkdir dir="${build}" />
    <mkdir dir="${build}/WEB-INF" />
    <mkdir dir="${build}/WEB-INF/classes" />
    <mkdir dir="${build}/WEB-INF/lib" />	
    <mkdir dir="${build}/WEB-INF/tags" />			
  </target>

• za pomoca depends ustalamy zależność zadań. Zadanie prepare będzie wykonane tylko wtedy gdy zadanie init zakończyło się poprawnie,
• katalog tags jest przeznaczony na własne biblioteki znaczników JSP, nie zawsze musi być potrzebny, tak samo jak lib (ogolne biblioteki klas dla całej apliakcji), ale tworzymy tu ogólną, przygotowaną na wszystkie przypadki programowania serwletów i JSP strukturę katalogową.

   <!-- Sciezka klas dla kompilacji -->

  <path id="classpath">
    <fileset dir="${catalina.home}/lib">
      <include name="*.jar"/>
    </fileset>
  </path>

• wygodną intsrukcją Anta jest fileset - definiowanie zbiorów plików. Tutaj mówimy, że pod identyfikatorem classpath ma się znaleźć zbiór wszystkich plików z rozszerzeniem jar z katalogu /lib katalogu instalacyjnego Tomcata (podanego w pliku properties pod nazwą catalina.home); użycie  include **/*.ext włączyłoby do zbioru wszystkie pliki z rozszerzeniem ext z katalogu dir i całego drzewa podkatalogów (rekursywnie) zaczynających się w katalogu dir.

  <target name="build" depends="prepare"
     description="Kompilacja i kopiowanie" >
    <javac srcdir="src" destdir="${build}/WEB-INF/classes" debug="on">
    	<include name="**/*.java" />
     	<classpath refid="classpath"/>
    </javac>
    <copy todir="${build}/WEB-INF">
      <fileset dir="web/WEB-INF"    >
        <include name="**/*.xml" />
        <include name="**/*.html" />
        <include name="**/*.tld" />
        <include name="**/*.properties" />
        <include name="**/*.txt" />
      </fileset>
    </copy>
    <copy todir="${build}">
      <fileset dir="web">
        <include name="**/*.html" />
        <include name="**/*.jsp" />
        <include name="**/*.jspf" />
        <include name="**/*.gif" />
      </fileset>
    </copy>
    <copy todir="${build}/WEB-INF/tags">
      <fileset dir="web">
        <include name="**/*.tag" />
      </fileset>
    </copy>
  </target>

• install - instalacja aplikacji - bardzo wygodne przy rozwijaniu (w obecnych wersjach Tomcata install działa jak deploy),
• reload - przeładowanie aplikacji (np, po zmianie kodu klas Javy; zmiana web.xml wymaga jednak ponownej instalacji),
• remove - usunięcie zainstalowanej aplikacji,
• deploy - wdrożenie aplikacji.

  <!-- definiowane zadania Anta dla Tomcata -->
  <taskdef name="install" classname="org.apache.catalina.ant.InstallTask"/>
  <taskdef name="reload"  classname="org.apache.catalina.ant.ReloadTask"/>
  <taskdef name="remove"  classname="org.apache.catalina.ant.RemoveTask"/>	
  <taskdef name="deploy" classname="org.apache.catalina.ant.DeployTask"/>	
  <taskdef name="undeploy" classname="org.apache.catalina.ant.UndeployTask"/>	

  <target name="install" description="Instaluje aplikacje"
          depends="build">
    <install url="${url}" username="${username}" password="${password}"
          path="/${context.path}" war="file:${build}"/>
  </target>

  <target name="install-config"
      description="Instaluje w oparciu o context.xml" depends="build">
     <install url="${url}" path="niewazne"
      config="file:${app.path}/${app}/context.xml"
      username="${username}" password="${password}"/>
  </target>


  <target name="reload" description="Przeladowuje  aplikacje"
          depends="build">
    <reload  url="${url}" username="${username}" password="${password}"
          path="/${context.path}"/>
  </target>

  <target name="remove" description="Usuwa aplikacje">
    <remove url="${url}" username="${username}" password="${password}"
          path="/${context.path}"/>
  </target>

• zmienna url zawiera lokator menedżera aplikacji, gdzieś wcześniej mogliśmy zapisać   <property name="url"      value="http://localhost:8080/manager"/> lub pobrać wartość tej właściowości z pliku .properties,
• zmienne username i password to nazwa użytkownikia i hasło potrzebne do dostępu do menedżera aplikacji (w Tomcacie specyfikujemy te wartości w pliku conf/tomcat-users.xml), zapewne wpiszemy je do pliku build.properties,
• context.path - to określona wcześniej ścieżka kontekstu,
• war - określa umiejscowienie aplikacji (w naszym przypadku jest to niespakowana struktura katalogowa,  znajdująca się pod katalogiem ${build}

username=admin
password=admin
catalina.home=E:/Serwery/apache-tomcat-6.0.13

<!--
    Projekt
-->

<!DOCTYPE project [
  <!ENTITY defbuild SYSTEM "../../common/defbuild.xml">
]>


<project name="moja aplikacja" default="build" basedir=".">
  <target name="init">
      <tstamp/>
  </target>

  &defbuild;

</project>

  <!-- Wlasciwosci dla dostepu do Managera aplikacji -->
  <property name="url"      value="http://localhost:8080/manager"/>

       <!-- Konfiguracja wlasciwosci  --> 
  <property file="../../common/build.properties"/>
  <property file="build.properties"/>
  <property name="build" value="${app.path}/${app}/build" />
  <property name="context.path" value="${app}" />


  <!-- Sciezka klas dla kompilacji -->

  <path id="classpath">
    <fileset dir="${catalina.home}/lib">
      <include name="*.jar"/>
    </fileset>
  </path>

  <!-- definiowane zadania Anta dla Tomcata -->
  <taskdef name="install" classname="org.apache.catalina.ant.InstallTask"/>
  <taskdef name="reload"  classname="org.apache.catalina.ant.ReloadTask"/>
  <taskdef name="remove"  classname="org.apache.catalina.ant.RemoveTask"/>	
  <taskdef name="deploy" classname="org.apache.catalina.ant.DeployTask"/>	
  <taskdef name="undeploy" classname="org.apache.catalina.ant.UndeployTask"/>	


  <target name="prepare" depends="init"
   	description="Buduje katalogi build">
    <mkdir dir="${build}" />
    <mkdir dir="${build}/WEB-INF" />
    <mkdir dir="${build}/WEB-INF/classes" />
    <mkdir dir="${build}/WEB-INF/lib" />	
    <mkdir dir="${build}/WEB-INF/tags" />			
  </target>


  <!-- wykonanie zadan -->

  <target name="install" description="Instaluje aplikacje"
          depends="build">
    <install url="${url}" username="${username}" password="${password}"
          path="/${context.path}" war="file:${build}"/>
  </target>

  <target name="install-config"  
      description="Instaluje w oparciu o context.xml" depends="build">
     <install url="${url}" path="/${context.path}" war="file:${build}"
      config="file:${app.path}/${app}/context.xml"
      username="${username}" password="${password}"/>
  </target> 


  <target name="reload" description="Przeladowuje  aplikacje"
          depends="build">
    <reload  url="${url}" username="${username}" password="${password}"
          path="/${context.path}"/>
  </target>

  <target name="remove" description="Usuwa aplikacje">
    <remove url="${url}" username="${username}" password="${password}"
          path="/${context.path}"/>
  </target>


  <target name="build" depends="prepare" 
     description="Kompilacja i kopiowanie" >
    <javac srcdir="src" destdir="${build}/WEB-INF/classes" debug="on">
    	<include name="**/*.java" />
     	<classpath refid="classpath"/>
    </javac>
    <copy todir="${build}/WEB-INF">
      <fileset dir="web/WEB-INF"    >
        <include name="**/*.xml" />
        <include name="**/*.html" />
        <include name="**/*.tld" />
        <include name="**/*.properties" />
        <include name="**/*.txt" />
      </fileset>
    </copy>
    <copy todir="${build}">
      <fileset dir="web">
        <include name="**/*.html" />
        <include name="**/*.jsp" />
        <include name="**/*.jspf" />
        <include name="**/*.gif" />
      </fileset>
    </copy>
    <copy todir="${build}/WEB-INF/tags">
      <fileset dir="web">
        <include name="**/*.tag" />
      </fileset>
    </copy>
  </target>

app=jsp-test
app.path=G:/webaps/SERWLETY

• najpierw ją usunąć - ant remove
• a poźniej zainstalować ponownie - ant install

  <target name="package"
      description="Pakuje WAR">
      <delete file="dist/${war.file}" />
      <jar jarfile="dist/${war.file}" >
        <fileset dir="${build}" />
      </jar>
  </target>

4. Serwlety - model działania i obsługa zleceń

• załadowanie klasy serwletu,
• utworzenie obiektu,
• inicjację.

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

public class Test extends HttpServlet {

  static String loadMsg = "Klasa zaladowana " + new Date();
  String createMsg = "\nSerwlet utworzony  " + new Date();
  String initMsg;
  String config1Msg = "\nW konstruktorze ServletConfig ",
         config2Msg = "\nW metodzie init ServletConfig ";

  public Test() {
    ServletConfig conf = getServletConfig();
    if (conf == null)
      config1Msg += "nie istnieje,\n" +
         "zatem nie ma dostepu do kontekstu i inicjalnych parametrów";
    else config1Msg +=  " istnieje !!??";
  }

  public void init() {
    initMsg  = "\nSerwlet zainicjowany " + new Date();
    ServletConfig conf = getServletConfig();
    if (conf == null) config2Msg +=  "nie istnieje !!??";
    else {
      config2Msg += "istnieje.\nMozemy odwolac sie do kontekstu" +
                     " i inicjalnych parametrów:\n";

    // Uzyskanie kontekstu i dostęp do niego - dwa równoważne sposoby
    ServletContext context1 = conf.getServletContext();
          // poniższe odwolanie oznacza getConfig().getServletContext()
    ServletContext context2 = getServletContext();
    String name = context2.getServletContextName();
    }
  }

  PrintWriter out;

  public void service(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException
  {
     out = resp.getWriter();
     out.println(loadMsg);
     out.println(createMsg);
     out.println(config1Msg);
     out.println(config2Msg);
     out.println("obsluga zlecenia przez metode service " + new Date());

     // Jezeli przedefinujemy metodę servis
     // zazwyczaj będziemy wołać super.service(...)
     // by przekazać zlecenie do obsługi przez konkretne metody
     // np. doGet lub doPost

     super.service(req, resp);
     out.close();
  }


  public void doGet(HttpServletRequest req, HttpServletResponse resp)
                 throws ServletException, IOException
  {

    out.println("\nWywolana metoda doGet " + new Date());
    out.close();
  }


}

Klasa zaladowana Mon Sep 01 01:59:04 CEST 2008

Serwlet utworzony  Mon Sep 01 01:59:04 CEST 2008

W konstruktorze ServletConfig nie istnieje,
zatem nie ma dostepu do kontekstu i inicjalnych parametrów

W metodzie init ServletConfig istnieje.
Mozemy odwolac sie do kontekstu i inicjalnych parametrów:

obsluga zlecenia przez metode service Mon Sep 01 01:59:04 CEST 2008

Wywolana metoda doGet Mon Sep 01 01:59:04 CEST 2008

• nazwy metody zlecenia,
• URL-a  zlecenia,
• nagłówków HTTP zlecenia,
• treści zlecenia (inaczej: ciała)

• pobrania śeieżek i dodatkowych informacji zawartych w URLu zlecenia (widzieliśmy już to na przykładach poprzednio),
  
• pobrania nagłówków HTTP zlecenia (ogólne metody: getHeaders(), getHeaderNames() getHeader(String) oraz przygotowane na często używane nagłówki np:  getLocale(), getContentType(), getCharacterEncoding(), getContentLength()),
• pobrania parametrów zlecenia (metody getParameterMap(), getParameterNames(), getParameterValues(), getParameter(String) - o parametrach będziemy mówić za chwilę
• pobrania lub ustalenia atrybutów zlecenia - czyli związancyh ze zleceniem obiektów, które mogą być tworzone przez serwer lub ustalane programistycznie przy przekazywaniu zlecenia do obsługi dalej, np. do innego serwletu (metody getAttributeNames(), getAttribute(), setAttribute(), removeAttribute()),
• pobrania strumiena wejściowego (bajtowego - getInputStream() lub znakowego - getReader()) poprzez który można przeczytać treść (ciało) zlecenia.

• kodu wyniku (np. 200 - wszystko OK, 404 - zasób nie znaleziony),
• nagłówków HTTP,
• treść (ciało) odpowiedzi.

• zwrócić tzw. przekierowanie adresu (redirected URL) za pomocą metody sendRedirect(...) - serwer HTTP przekieruje klienta na podany jako argument metody adres; użyć metody można tylko wtedy, gdy odpowiedź nie została zatwierdzona; po przekierowaniu nie wolno już nic pisać do strumienia wyjściwego,
• przekazać obsługę zlecenia do innego komponentu WEB  (serwletu, strony JSP) używając obiektu RequestDispatcher.

• przygotowania zlokalizowanych tekstów w ResourceBundle,
• odczytania z nagłówków zlecenia preferowanego języka użytkownika (nagłówek accept-language, dostarczany też przez metodę getLocale()),
• wybrania tekstu odpowiedzi z odpowiedniego ResourceBundle,
• ustalenie typu treści i kodowanie odpowiedzi,
• (opcjonalnie, w zalezności od śrdowiska kodowania tej odpowiedzi w odpowiedniej stronie kodowej.

package international;
import java.util.*;

public class Messages_en extends ListResourceBundle {
     public Object[][] getContents() {
         return contents;
     }

    static final Object[][] contents = {
       { "hello", "Hello!" },
       { "now", "Now is: " },
       { "charset", "ISO-8859-1" }
    };
}

package international;
import java.util.*;

public class Messages_pl extends ListResourceBundle {
     public Object[][] getContents() {
         return contents;
     }

    static final Object[][] contents = {
       { "hello", "Dzień dobry!" },
       { "now", "Teraz będzie, a właściwie już jest" },
       { "charset", "ISO-8859-2" }
    };
}

1. W zasobach dla danego języka określimy właściwą stronę kodową, nie polegając na kodowaniu, które ew. moglibyśmy odczytać z nagłówka zlecenia (getCharacterEncoding()), bo mogłoby okazać się fałszywe.
2. Zasoby zlokalizowane przygotowujemy jako klasy ListResourceBundle, bowiem - z niejasnych  powodów - serwlety nie umieją właściwie przekodować do Unicode'u tekstów zapisanych w plikach .properties (PropertiesBundle).
3. Musimy dostarczyć wszystkich klas z odpowiednimi przyrostkami lokalizacyjnymi (Messages_pl, Messages_en). Inaczej bowiem niż w normalnych apliakcjach w serwletach przy braku klasy dla danej lokalizacji nie jest ładowany domyślny zasób (Messages) o ile tylko nie zrestartowano serwera. Ma to zapewne związek z obsługą ładowania klas przez Tomcat.
   

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.text.*;

public class Time1 extends HttpServlet {

  public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
                 throws ServletException, java.io.IOException
  {
     // Jaki jest preferowany język klienta?
     Locale locale = request.getLocale();

     // Uzyskanie odpowiedniego zlokalizowanego zasobu
     ResourceBundle msg = ResourceBundle.getBundle(
                             "international.Messages", locale);

     // Zlokalizowane komunikaty i odpowiednia strona kodowa
     String hello = msg.getString("hello");
     String now = msg.getString("now");
     String charset = msg.getString("charset");

     // Ustalenie typu i kodowania odpowiedzi
     // Musi być ustalone przed uzyskaniem strumienia wyjściowego
     response.setContentType("text/html; charset=" + charset);

     // Pobranie strumienia wyjściowego
     // z zapewnieniem własciwego kodowania
     // czasami wystarcza samo: PrintWriter out = response.getWriter()

     PrintWriter out = new PrintWriter(
        new OutputStreamWriter(response.getOutputStream(), charset),
        true);



     out.println("<h2>" + hello + "<br>" + now + "<br>" );
     out.println(getDate(locale) + "</h2>");
     out.close();
  }


  private String getDate(Locale loc) {
    Date data = new Date();
    DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG,
                                                   DateFormat.MEDIUM,
                                                   loc);
    return df.format(data);
  }


}

• po pierwsze, przedefiniowaliśmy tylko metodę doGet(...) i powstaje pytanie czy to wystarczy aby serwlet działal w  każdych okolicznościach? Musimy chyba bliżej przyjrzeć się metodom zleceń HTTP i zaraza to zrobimy.
• po drugie, pobieranie zasobów lokalizacyjnych umieszczone jest w metodzie doGet() i jest wykonywane za każdym połączeniem. Być może warto zoptymalizowac nieco kod pod kątem wielokrotnego łączenia się tego samego użytkownika (który normalnie nie zmienia przy każdym połączeniu języka przeglądarki). Tu na pomoc przyjdzie nam pojęcie sesji i metody związane z zarządzaniem sesjami. O tym będziemy mówić nieco poźniej.

• użytkownik wypelni informacje  na pasku adresu i  naciśnie ENTER,
• kliknie w link z adresem,
• wyśle formularz (np. przez kliknięcie w przycisk "Wyślij"), który albo nie specyfikuje metody (brak paarmetru METHOD, alb specyfikuje jako metodę - GET).

<html>
<head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1250">
 <title>Pokazuje date i czas</title>
</head>

<body>
<center><h2>Data i czas</h2></center>
<hr>
<form method="post" action ="http://localhost:8080/serwlety1/Time">
Aby zobaczyć datę i czas wciśnij przycisk&nbsp&nbsp
<input type="submit" value="Data i czas">
</form>
</body>
</html>

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.text.*;

public class ShowTime0 extends HttpServlet {

  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
     Locale locale = req.getLocale();
      // ...
      out.close();
  }

// ...

//--- Stanadardowa część serwletu -----------------------------------
  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

}

5. Parametry zleceń

<html>
<head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1250">
 <title>Testowanie</title>
</head>
<body>
<center><h2>Testowanie parametrów</h2></center>
<hr>
<form method="get" action="http://localhost:8080/serwlety1/params1">
id<input type="text" size="50" name="ident"><br>
p1<input type="text" size="50" name="p1"><br>
p2<input type="text" size="50" name="p2"><br>
p3<input type="text" size="50" name="p3"><br>
p4<input type="text" size="50" name="p4"><br>
p5<input type="text" size="50" name="p5"><br>
p6<input type="text" size="50" name="p6"><br>
 _
<br><input type="submit" value="Wyślij formularz">
</form>
</body></html>

public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
      PrintWriter out = resp.getWriter();
      out.println("Metoda: " + req.getMethod());

      out.println("Query : " + req.getQueryString());
      out.println("Parametry:");
      Enumeration pnams = req.getParameterNames();
      while (pnams.hasMoreElements()) {
        String name = (String) pnams.nextElement();
        String value = req.getParameter(name);
        out.println(name + " = "  + value);
      }
      out.println("Dostęp przez mapę");
      Map map = req.getParameterMap();
      String[] val = (String[]) map.get("ident");
      out.println("Parametr o nazwie ident");
      out.println("- z mapy uzyskujemy tablice String[]");
      out.println("- jej rozmiar " + val.length );
      out.println("- jej elementy:" );
      for (int i=0; i<val.length; i++) out.println(val[i]);

     out.close();
  }

Metoda: GET
Query : ident=Pies&p1=a&p2=b&p3=c&p4=d&p5=e&p6=f
Parametry:
p6 = f
p5 = e
p4 = d
p3 = c
ident = Pies
p2 = b
p1 = a
Dostep przez mape
Parametr o nazwie ident
- z mapy uzyskujemy tablice String[]
- jej rozmiar 1
- jej elementy:
Pies

...
<form method="post" action="http://localhost:8080/serwlety1/params1">
...

Metoda: POST
Query : null
// ... dalej jak w metodzie GET

  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
    PrintWriter out = resp.getWriter();
    out.println("Metoda: " + req.getMethod());

    // Przy zleceniu POST
    // Albo uzyskujemy parametry przez metody getParameter...
    // albo czytamy je ze strumienia jako "ciało" zlecenia
    // ale nie równocześnie i to i to

    boolean readBodyStream = true;  // czytamy ze strumienia

    if (!readBodyStream) {
       // ... poprzedni kod
    }
    else {
      out.println("Czytanie tresci (ciała) zlecenia ze strumienia:");

      BufferedReader br = req.getReader();
      String line;
      while ((line = br.readLine()) != null) out.println(line);
      br.close();
    }

    out.close();
  }

Metoda: POST
Czytanie tresci (ciala) zlecenia ze strumienia:
ident=Pies&p1=a&p2=b&p3=c&p4=d&p5=e&p6=f

<html>
<head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1250">
 <title>Testowanie</title>
</head>
<body>
<center><h2>Testowanie wyrażeń regularnych</h2></center>
<hr>
<form method="post" action="http://localhost:8080/serwlety1/regex1">
Wzorzec: <br>
<input type="text" size="30" name="regex"><br>
Tekst:<br>
<input type="text" size="50" name="input"><br><br>  
<input type="submit" value="Pokaż wynik wyszukiwania">
</form>
</body></html>

  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {

    String charset = "windows-1250";

    // Uwaga. Należy ustalić właściwą stronę kodową zlecenia
    // bez tego parametry nie będą właściwie odczytane
    // Tu - ustalamy stronę windows-1250, bo nasz formularz
    // jest zapisany w takim właśnie kodowaniu

    req.setCharacterEncoding(charset);

    resp.setContentType("text/html; charset=" + charset);

    PrintWriter out = resp.getWriter();

    String regex = req.getParameter("regex");
    String input = req.getParameter("input");

    if (regex == null || input == null) {
      out.println("<h2>Wadliwe argumenty wywołania</h2>");
      out.close();
      return;
    }

    out.println("<h3>Wyrażenie:<br>\"" + regex + "\"</h3>");
    out.println("<h3>Tekst:<br>\"" + input + "\"</h3>");
    out.println("<hr>");

    try {
      Pattern pattern = Pattern.compile(regex);
      Matcher matcher = pattern.matcher(input);
      boolean found = matcher.find();
      if (!found)
         out.println("<h3>Nie znaleziono żadnego podłańcucha " +
                      "pasującego do wzorca</h3>");
      else {
          out.println("<h3>Dopasowano:</h3>");
          out.println("<ol>");
        do {
          out.println("<li>podłańcuch \"" + matcher.group() +
                   "\" od pozycji " + matcher.start() +
                   " do pozycji " + (matcher.end()-1) + "</li>");
        } while(matcher.find());
        out.println("</ol>");
      }
    } catch (PatternSyntaxException exc) {
        out.println("<h2>Błąd w wyrażeniu</h2>");
    } finally {
        out.close();
    }
  }

• przygotować część pliku HTML z formularzem w postaci (swoisty szablon)

<center><h2>Testowanie wyrażeń regularnych</h2></center>
<hr>
<form method="post">
Wzorzec: <br>
<input type="text" size="30" name="regex"><br>
Tekst:<br>
<input type="text" size="50" name="input"><br><br>
<input type="submit" value="Pokaż wynik wyszukiwania">
</form>

• w serwlecie odczytać ten plik i wpisać jego zawartość na generowaną stronę,
• jeżeli serwlet nie może uzyskać parametrów (pierwsze odwołanie do serwletu) poprzestajemy na wygenerowaniu strony z formularzem,
• jeżeli są parametry - serwlet  przetwarza wyrażenie regularne i dopisuje do generowanej strony wyniki wyszukiwania.

    <servlet>
       <servlet-name>RegexTest</servlet-name>
       <description>Regularne wyrazenia 1</description>
       <servlet-class>RegexTest</servlet-class>
       <init-param>
          <param-name>regexFormFile</param-name>
          <param-value>regexform.html</param-value>
       </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>RegexTest</servlet-name>
        <url-pattern>/regex1</url-pattern>
    </servlet-mapping>

public class RegexTest extends HttpServlet {

  private PrintWriter out;
  private void printEndTag() { out.println("</body></html>"); }

  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {

    String charset = "ISO8859-2";
    req.setCharacterEncoding(charset);
    resp.setContentType("text/html; charset=" + charset);
    out = resp.getWriter();
    out.println("<html>");
    out.println("<head><title>Testowanie</title></head>");
    out.println("<body>");

    // Nazwę pliku z formularzem dostarczymy
    // jako parametr inicjalny serwletu
    String formFile = getInitParameter("regexFormFile");

    // Przeczytamy go i wpiszemy na generowaną stronę

    ServletContext context = getServletContext();
    InputStream in = context.getResourceAsStream("/WEB-INF/"+formFile);
    BufferedReader br = new BufferedReader( new InputStreamReader(in));
    String line;
    while ((line = br.readLine()) != null) out.println(line);

    // Pobieramy parametry formularza
    String regex = req.getParameter("regex");
    String input = req.getParameter("input");

    // Przy pierwszym odwołaniu do serwletu - parametrów nie ma
    // zatem poprzestajemy na wygenerowaniu formularza

    if (regex == null || input == null) {
      printEndTag();
      out.close();
      return;
    }

    // W przeciwnym razie jakieś parametry (chcoćby puste) już są
    // Przetwarzamy je i uzupełniamy stronę z formularzem

    out.println("<hr>");
    out.println("Wzorzec: \"" + regex + "\"<br>");
    out.println("Tekst  : \"" + input + "\"<br>");

    try {
      Pattern pattern = Pattern.compile(regex);
      Matcher matcher = pattern.matcher(input);
      boolean found = matcher.find();
      if (!found)
         out.println("<h3>Nie znaleziono żadnego podłańcucha " +
                      "pasującego do wzorca</h3>");
      else {
          out.println("<h3>Dopasowano:</h3>");
          out.println("<ol>");
        do {
          out.println("<li>podłańcuch \"" + matcher.group() +
                   "\" od pozycji " + matcher.start() +
                   " do pozycji " + (matcher.end()-1) + "</li>");
        } while(matcher.find());
        out.println("</ol>");
      }
    } catch (PatternSyntaxException exc) {
        out.println("<h2>Błąd w wyrażeniu</h2>");
    } finally {
        printEndTag();
        out.close();
    }
  }

// ... metody doGet o doPost wołające serviceRequest

}

6.  Serwlety i architektura MVC

    try {
      Pattern pattern = Pattern.compile(regex);                   // Logika
      Matcher matcher = pattern.matcher(input);                   // Logika
      boolean found = matcher.find();                             // Logika
      if (!found)                                                 // Logika
         out.println("<h3>Nie znaleziono żadnego podłańcucha " +  // Prezentacja
                      "pasującego do wzorca</h3>");
      else {                                                      // Logika
          out.println("<h3>Dopasowano:</h3>");                    // Prezentacja
          out.println("<ol>");                                    // Prezentacja
        do {
          out.println("<li>podłańcuch \"" + matcher.group() +     // L + P
                   "\" od pozycji " + matcher.start() +           // L + P
                   " do pozycji " + (matcher.end()-1) + "</li>"); // L + P
        } while(matcher.find());
        out.println("</ol>");                                     // Prezentacja
      }
    } catch (PatternSyntaxException exc) {                        // Logika
        out.println("<h2>Błąd w wyrażeniu</h2>");                 // Prezentacja
    } finally {                                                   // Logika
        printEndTag();                                            // Prezentacja
        out.close();                                              // Prezentacja
    }

• dla każdej aplikacji możemy ustalić inicjalne parametry kontekstu (element context-param w pliku web.xml); parametry te będą dostępne dla wszystkich serwletów w aplikacji poprzez metodę getInitParameter klasy ServletContext,
• dla całej aplikacji można dynamicznie ustalać atrybuty kontekstu , zawierające referencje do dowolnych obiektów; ustalać, odczytywac i usuwać atrybuty może każdy z serwletów aplikacji za pomocą metod setAttribute(Object), Object getAttribute(), removeAttribute(Object) klasy ServletContext,
• serwlety mogą tworzyć sesje i poslugiwac się atrybutami sesji; sesja identyfikuje połączenie z danym klientem (które może być przez jakiś, ustalony czas nieaktywne); bieżącą sesję uzyskujemy jako obiekt klasy HttpSession za pomocą metody getSession() z klasy HttpServletRequest()
• atrybuty sesji pozwalają zapisywac i wynieniać informacje dotyczące danej sesji - tu również mamy metody setAttribute(..), getAttribute, removeAttribute() tym razem z klasy HttpSession, które to metody może wywoływac każdy z serwletów aplikacji. 
• zlecenie może być przekazane przez serwlet do obsługi (całkowitej lub częściowej) innemu serwletowi; służy temu obiekt RequestDispatcher, uzyskiwany od aktualnego zlecenia (lub kontekstu).
  

• klasę odpowiedzialną za wykonanie pracy (nazwiemy ją klasą działania); zbudujemy ją przy tym w ogólny sposób, tak że będzie mogła być wykorzystana i w innych sytuacjach, niekoniecznie w środowisku aplikacji WEB,
• klasę GetParamServ - serwlet pobierający wartości parametrów (np. z formularza HTML),
• klasę ResultPresent - serwlet prezentacji wyników
• klasę ControllerServ, która bedzie stanowić serwlet-kontroler, przyjmujący zlecenie i uaktywniający inne komponenty (w tym pobieranie parametrów, wykonanie pracy, prezentację).

1. serwlet-kontroler mógł bez rekompilacji obsługiwać dowolne klasy działań (!) oraz przekazywać zadania pobierania parametrów i prezentacji wyników dowolnym serwletom pobierania parametrów i pokazywania wyników,
2. serwlet pobierania parametrów nie był zależny od nazw i opisu parametrów (w szczególności ich zlokalizowanych opisów),
3. serwlet prezentacji mógł być wykorzystywany do prezentacji dowolnych wyników.

import java.util.*;

public interface Command {
   void init();
   void setParameter(String name, Object value);
   Object getParameter(String name);
   void execute();
   List getResults();
   void setStatusCode(int code);
   int getStatusCode();
}

import java.util.*;
import java.io.*;

public class CommandImpl implements Serializable, Command {

  private Map parameterMap = new HashMap();
  private List resultList = new ArrayList();

  private int statusCode;

  public CommandImpl() {}

  public void init() {}

  public void setParameter(String name, Object value) {
    parameterMap.put(name, value);
  }

  public Object getParameter(String name) {
    return parameterMap.get(name);
  }

  public void execute() {}

  public List getResults() {
    return resultList;
  }

  public void addResult(Object o) {
    resultList.add(o);
  }

  public void addResult(String s) {
    addResult(new Object[] { s } );
  }


  public void clearResult() {
    resultList.clear();
  }

  public void setStatusCode(int code) {
    statusCode = code;
  }

  public int getStatusCode() {
    return statusCode;
  }

}

import java.util.*;
import java.io.*;
import java.util.regex.*;

public class FindCommand extends CommandImpl implements Serializable {

  public FindCommand() {}

  public void execute() {
    clearResult();
    String regex = (String) getParameter("regex");
    String input = (String) getParameter("input");
    if (regex == null || input == null) {
      setStatusCode(1);
      return;
    }
    Pattern pattern;
    try {
      pattern = Pattern.compile(regex);
    } catch (PatternSyntaxException exc) {
       setStatusCode(2);
       return;
    }
    Matcher matcher = pattern.matcher(input);
    boolean found = matcher.find();
    if (!found) setStatusCode(3);
    else {
      setStatusCode(0);
      do {
        addResult( new Object[] { "\"" + matcher.group() + "\"",
                                  new Integer(matcher.start()),
                                  new Integer(matcher.end()-1)
                                });

      } while(matcher.find());
    }
  }

}

     .....
    <context-param>
       <param-name>presentationServ</param-name>
       <param-value>/presentation</param-value>
    </context-param>

    <context-param>
       <param-name>getParamsServ</param-name>
       <param-value>/getparams</param-value>
    </context-param>

    <context-param>
       <param-name>commandClassName</param-name>
       <param-value>FindCommand</param-value>
    </context-param>
    .....

public class ControllerServ extends HttpServlet {

  private ServletContext context;
  private Command command;            // obiekt klasy dzialania
  private String presentationServ;    // nazwa serwlet prezentacji
  private String getParamsServ;       // mazwa serwletu pobierania parametrów
  private Object lock = new Object(); // semafor dla synchronizacji
                                      // odwołań wielu wątków
  public void init() {

    context = getServletContext();

    presentationServ = context.getInitParameter("presentationServ");
    getParamsServ = context.getInitParameter("getParamsServ");
    String commandClassName = context.getInitParameter("commandClassName");

    // Załadowanie klasy Command i utworzenie jej egzemplarza
    // który będzie wykonywał pracę
    try {
      Class commandClass = Class.forName(commandClassName);
      command = (Command) commandClass.newInstance();
    } catch (Exception exc) {
        throw new NoCommandException("Nie mogę stworzyć obiektu klasy " +
                                      commandClassName);
    }
  }

// ...

public class NoCommandException extends RuntimeException {
  public NoCommandException() { super(); }
  public NoCommandException(String msg) { super(msg); }
}

public class ControllerServ extends HttpServlet {

  private ServletContext context;
  private Command command;            // obiekt klasy wykonawczej
  private String presentationServ;    // nazwa serwlet prezentacji
  private String getParamsServ;       // mazwa serwletu pobierania parametrów
  private Object lock = new Object(); // semafor dla synchronizacji
                                      // odwołań wielu wątków
  public void init() {

    context = getServletContext();

    presentationServ = context.getInitParameter("presentationServ");
    getParamsServ = context.getInitParameter("getParamsServ");
    String commandClassName = context.getInitParameter("commandClassName");

    // Załadowanie klasy Command i utworzenie jej egzemplarza
    // który będzie wykonywał pracę
    try {
      Class commandClass = Class.forName(commandClassName);
      command = (Command) commandClass.newInstance();
    } catch (Exception exc) {
        throw new NoCommandException("Couldn't find or instantiate " +
                                      commandClassName);
    }
  }

  // Obsługa zleceń
  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {

    resp.setContentType("text/html");

    // Wywolanie serwletu pobierania parametrów
    RequestDispatcher disp = context.getRequestDispatcher(getParamsServ);
    disp.include(req,resp);

    // Pobranie bieżącej sesji
    // i z jej atrybutów - wartości parametrów
    // ustalonych przez servlet pobierania parametrów
    // Różne informacje o aplikacji (np. nazwy parametrów)
    // są wygodnie dostępne poprzez własną klasę BundleInfo

    HttpSession ses = req.getSession();

    String[] pnames = BundleInfo.getCommandParamNames();
    for (int i=0; i<pnames.length; i++) {

      String pval = (String) ses.getAttribute("param_"+pnames[i]);

      if (pval == null) return;  // jeszcze nie ma parametrów

      // Ustalenie tych parametrów dla Command
      command.setParameter(pnames[i], pval);
    }

    // Wykonanie działań definiowanych przez Command
    // i pobranie wyników
    // Ponieważ do serwletu może naraz odwoływać sie wielu klientów
    // (wiele watków) - potrzebna jest synchronizacja
    // przy czym rrygiel zamkniemy tutaj, a otworzymy w innym fragmnencie kodu
    // - w serwlecie przentacji (cały cykl od wykonania cmd do poazania wyników jest sekcją krytyczną) 

    Lock mainLock = new ReentrantLock();

    mainLock.lock();
      // wykonanie
      command.execute();

      // pobranie wyników
      List results = (List) command.getResults();

      // Pobranie i zapamiętanie kodu wyniku (dla servletu prezentacji)
      ses.setAttribute("StatusCode", new Integer(command.getStatusCode()));

      // Wyniki - będą dostępne jako atrybut sesji
      ses.setAttribute("Results", results);
      ses.setAttribute("Lock", mainLock);    // zapiszmy lock, aby mozna go było otworzyć później


    // Wywołanie serwletu prezentacji
    disp = context.getRequestDispatcher(presentationServ);
    disp.forward(req, resp);
  }


  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

}

• strona kodowa właściwa dla danej lokalizacji (klucz "charset").
• napisy nagłówkowe, które mają sie pojiwić na generowanej przez serwlet pobierania parametrów stronie (klucz "headers"),
• parametry - ich nazwy i opisy (każdy parametr jest dany przez klucz param_nazwaparametru, a wartość zapisana pod ty kluczen będzie stanowić opsi parametru, pojawiający się np. w formulrazu),
• napis na przycisku wysyłania formularza (klucz "submit"),
• ew. napisy pojawiające się na końcu generowanej strony z formularzem (klucz "footers"),
• kounikaty związane z kodami wyniku (klucz "resCode"),
• dodatkowe lementy opisowe dla wyników (klucz "resDescr").

public class RegexParamsDef_pl extends ListResourceBundle {
     public Object[][] getContents() {
         return contents;
     }

    static final Object[][] contents = {
       { "charset", "ISO-8859-2" },
       { "header", new String[] { "Testowanie wyrażeń regularnych" } },
       { "param_regex", "Wzorzec:" },
       { "param_input", "Tekst:" },
       { "submit", "Pokaż wyniki wyszukiwania" },
       { "footer", new String[] { } },
       { "resCode", new String[]
                    { "Dopasowano", "Brak danych",
                      "Wadliwy wzorzec", "Nie znaleziono dopasowania" }
                    },
       { "resDescr",
            new String[] { "podłańcuch", "od poz.", "do poz.", "" } },
    };
}

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;


class BundleInfo {

  static private String[] commandParamNames;
  static private String[] commandParamDescr;
  static private String[] statusMsg;
  static private String[] headers;
  static private String[] footers;
  static private String[] resultDescr;
  static private String charset;
  static private String submitMsg;

  static void generateInfo(ResourceBundle rb) {

    synchronized (BundleInfo.class) {  // konieczne ze względu
                                       // na możliwość odwołań
      List cpn = new ArrayList();      // z wielu egzemplarzy serwletów
      List cpv = new ArrayList();
      Enumeration keys = rb.getKeys();
      while (keys.hasMoreElements()) {
        String key = (String) keys.nextElement();
        if (key.startsWith("param_")) {
          cpn.add(key.substring(6));
          cpv.add(rb.getString(key));
        }
        else if (key.equals("header")) headers = rb.getStringArray(key);
        else if (key.equals("footer")) footers = rb.getStringArray(key);
        else if (key.equals("resCode")) statusMsg = rb.getStringArray(key);
        else if (key.equals("resDescr")) resultDescr = rb.getStringArray(key);
        else if (key.equals("charset")) charset = rb.getString(key);
        else if (key.equals("submit")) submitMsg = rb.getString(key);
      }
      commandParamNames = (String[]) cpn.toArray(new String[0]);
      commandParamDescr = (String[]) cpv.toArray(new String[0]);
    }
  }

  public static String getCharset() {
    return charset;
  }

  public static String getSubmitMsg() {
    return submitMsg;
  }

    public static String[] getCommandParamNames() {
    return commandParamNames;
  }

  public static String[] getCommandParamDescr() {
    return commandParamDescr;
  }

  public static String[] getStatusMsg() {
    return statusMsg;
  }

  public static String[] getHeaders() {
    return headers;
  }

  public static String[] getFooters() {
    return footers;
  }

  public static String[] getResultDescr() {
    return resultDescr;
  }

}


// Serwlet włączany wyłącznie z serwletu pobierania parametrów
// Ładuje  ResourceBundle i przekazuje go klasie BundleInfo,
// która odczytuje info i daje wygodną formę jej pobierania
// w innych serwletach.
// Ładowanie zasobów i ich przygotowanie przez klasę BundleInfo
// następuje tylko raz na sesję.


public class ResourceBundleServ extends HttpServlet {

  private String resBundleName;

  public void init() {
    resBundleName = getServletContext().getInitParameter("resBundleName");
  }

  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
    HttpSession ses = req.getSession();
    ResourceBundle paramsRes = (ResourceBundle) ses.getAttribute("resBundle");

    // W tej sesji jeszcze nie odczytaliśmy zasobów
    if (paramsRes == null) {
       Locale loc = req.getLocale();
       paramsRes = ResourceBundle.getBundle(resBundleName, loc);
       ses.setAttribute("resBundle", paramsRes);

       // Przygotowanie zasobów w wygodnej do odczytu formie
       BundleInfo.generateInfo(paramsRes);
    }

    // ... a jeśli sesja się nie zmieniła - to nie mamy nic do roboty
  }
//...
}

// SERWLET POBIERANIA PARAMETRÓW

public class GetParamsServ extends HttpServlet {

  private ServletContext context;
  private String resBundleServ;    // nazwa serwletu przygotowującego
                                   // sparametryzowaną informacje


  // Inicjacja
  public void init() {
    context = getServletContext();
    resBundleServ = context.getInitParameter("resBundleServ");
  }

  // Obsługa zleceń
  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {


    // Włączenie serwletu przygotowującego informacje z z zasobów
    // (ResourceBundle). Informacja będzie dostępna poprzez
    // statyczne metody klasy BundleInfo

    RequestDispatcher disp = context.getRequestDispatcher(resBundleServ);
    disp.include(req, resp);

    // Pobranie potrzebnej informacji
    // ktora została wczesniej przygotowana
    // przez klasę BundleInfo na podstawie zlokalizowanych zasobów

    // Zlokalizowana strona kodowa
    String charset = BundleInfo.getCharset();

    // Napisy nagłówkowe
    String[] headers = BundleInfo.getHeaders();

    // Nazwy parametrów (pojawią się w formularzu,
    // ale również są to nazwy parametrów dla Command)
    String[] pnames = BundleInfo.getCommandParamNames();

    // Opisy parametrów - aby było wiadomo co w formularzu wpisywać
    String[] pdes   = BundleInfo.getCommandParamDescr();

    // Napis na przycisku
    String submitMsg = BundleInfo.getSubmitMsg();

    // Ew. końcowe napisy na stronie
    String[] footers = BundleInfo.getFooters();

    // Ustalenie właściwego kodowania zlecenia
    // - bez tego nie będzie można własciwie odczytać parametrów
    req.setCharacterEncoding(charset);

    // Pobranie aktualnej sesji
    // w jej atrybutach są/będą przechowywane
    // wartości parametrów

    HttpSession session = req.getSession();

    // Generowanie strony

    resp.setCharacterEncoding(charset);
    PrintWriter out = resp.getWriter();

    out.println("<center><h2>");
    for (int i=0; i<headers.length; i++)
       out.println(headers[i]);
    out.println("</center></h2><hr>");

       // formularz
    out.println("<form method=\"post\">");
    for (int i=0; i<pnames.length; i++) {
     out.println(pdes[i] + "<br>");
     out.print("<input type=\"text\" size=\"30\" name=\"" +
                   pnames[i] +  "\"");

       // Jezeli są już wartości parametrów - pokażemy je w formularzu
      String pval = (String) session.getAttribute("param_"+pnames[i]);
      if (pval != null) out.print(" value=\"" + pval + "\"");
      out.println("><br>");
    }
    out.println("<br><input type=\"submit\" value=\"" + submitMsg + "\">");
    out.println("</form>");

    // Pobieranie parametrów z formularza

    for (int i=0; i<pnames.length; i++) {
      String paramVal = req.getParameter(pnames[i]);
         // Jeżeli brak parametru (ów) - konczymy
      if (paramVal == null) return;

      // Jest parametr - zapiszmy jego wartość jako atrybut sesji.
      // Zostanie on pobrany przez Controller
      // który ustali te wartości dla wykonania Command

      session.setAttribute("param_" + pnames[i], paramVal);

    }
  }

  //..metody doGet i doPost - wywołują serviceRequest
}

public class ResultPresent extends HttpServlet {


  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
    ServletContext context = getServletContext();

    // Włączenie strony generowanej przez serwlet pobierania parametrów
    // (formularz)
    String getParamsServ = context.getInitParameter("getParamsServ");
    RequestDispatcher disp = context.getRequestDispatcher(getParamsServ);
    disp.include(req,resp);

    // Uzyskanie wyników i wyprowadzenie ich
    // Controller po wykonaniu Command zapisał w atrybutach sesji
    // - referencje do listy wyników jako atrybut "Results"
    // - wartośc kodu wyniku wykonania jako atrybut "StatusCode"

    HttpSession ses = req.getSession();
    Lock mainLock = (Lock) ses.getAttribute("Lock");
    mainLock.unlock();
    List results = (List) ses.getAttribute("Results");
    Integer code = (Integer) ses.getAttribute("StatusCode");


    PrintWriter out = resp.getWriter();
    out.println("<hr>");

    // Uzyskanie napisu właściwego dla danego "statusCode"
    String msg = BundleInfo.getStatusMsg()[code.intValue()];
    out.println("<h2>" + msg + "</h2>");

    // Elementy danych wyjściowych (wyników) mogą być
    // poprzedzane jakimiś opisami (zdefiniowanymi w ResourceBundle)
    String[] dopiski = BundleInfo.getResultDescr();

    // Generujemy raport z wyników
    out.println("<ul>");
    for (Iterator iter = results.iterator(); iter.hasNext(); ) {
      out.println("<li>");

      int dlen = dopiski.length;  // długość tablicy dopisków
      Object res = iter.next();
      if (res.getClass().isArray()) {  // jezeli element wyniku jest tablicą
        Object[] res1 = (Object[]) res;
        int i;
        for (i=0; i < res1.length; i++) {
          String dopisek = (i < dlen ? dopiski[i] + " " : "");
          out.print(dopisek + res1[i] + " ");
        }
        if (dlen > res1.length) out.println(dopiski[i]);
      }
      else {                                      // może nie być tablicą
        if (dlen > 0) out.print(dopiski[0] + " ");
        out.print(res);
        if (dlen > 1) out.println(" " + dopiski[1]);
      }
      out.println("</li>");
    }
    out.println("</ul>");
  }


  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

}

import java.util.*;

public class StringCmdDef_pl extends ListResourceBundle {
     public Object[][] getContents() {
         return contents;
     }

    static final Object[][] contents = {
       { "charset", "ISO-8859-2" },
       { "header", new String[] { "Działania na Stringach" } },
       { "param_input1", "Tekst 1:" },
       { "param_input2", "Tekst 2:" },
       { "param_cmd", "Polecenie:" },
       { "submit", "Wykonaj" },
       { "footer", new String[] { } },
       { "resCode", new String[]
                    { "Wynik:", "Brak danych",
                      "Wadliwe polecenie, dostępne: upper, lower, words" }
                    },
       { "resDescr",
            new String[] { "" } },
    };
}

import java.io.*;
import java.util.*;

public class StringCommand extends CommandImpl implements Serializable {

  public StringCommand() {}

  public void execute() {
    clearResult();
    String input1 = (String) getParameter("input1");
    String input2 = (String) getParameter("input2");
    String cmd =   (String) getParameter("cmd");
    if (input1 == null || input2 == null || cmd == null) {
      setStatusCode(1);
      return;
    }


   String input = input1 + " " + input2;


   setStatusCode(0);
   if (cmd.equals("upper")) addResult(input.toUpperCase());
   else if (cmd.equals("lower")) addResult(input.toLowerCase());
   else if (cmd.equals("words")) {
     StringTokenizer st = new StringTokenizer(input);
     while (st.hasMoreTokens())  addResult(st.nextToken());
   }
   else setStatusCode(2);
 }

}

7. Serwlety i bazy danych

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.sql.*;
import javax.sql.*;

public class DbServlet1 extends HttpServlet {

  String url = "jdbc:derby://localhost/ksidb";
  String uid = "APP";
  String pwd = "APP";
  Connection con;


  public void init() throws ServletException {
    try {
     con = DriverManager.getConnection(url, uid, pwd);  //  JDBC 4.0 - dostęp przez SPI
    } catch (Exception exc) {
        throw new ServletException("Nie ustanowiono połaczenia z bazą", exc);
    }
  }


  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
   resp.setContentType("text/html; charset=windows-1250");
   PrintWriter out = resp.getWriter();
   out.println("<h2>Lista dostępnych książek</h2>");
   String sel = "select * from pozycje";
   out.println("<ol>");
   try  {
      Statement stmt = con.createStatement();
      ResultSet rs = stmt.executeQuery(sel);
      while (rs.next())  {
        String tytul = rs.getString("tytul");
        float cena  = rs.getFloat("cena");
        out.println("<li>" + tytul + " - cena: " + cena + "</li>");
      }
      rs.close();
      stmt.close();
    } catch (SQLException exc)  {
       out.println(exc.getMessage());
    }
    out.close();
  }

   public void destroy() {
     try {
       con.close();
     } catch (Exception exc) {}
   }


  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

}

• obiekt Connection  może być współdzielony przez wiele wątków, a nasz program nie jest na to przygotowany (dostęp do Connection nie jest wielowątkowo bezpieczny); w środowisku WEB aplikacji jest to szczególnie ważne, bo aplikacja powinna móc obsługiwać równocześnie dużą liczbę połączeń,
• połaczenie z bazą danych jest otwierane przy inicjacji serwletu i utrzymywane przez cały czas życia serwletu (co oczywiście wcale nie jest potrzebne i prowadzi do zmniejszenia efektywności w środowiskach, gdzie działa wiele serwletów bazodanowych),
• połączenie może wygasnąć z jakichś powodów (np. serwer bazodanowy zamknie je ze względu na długą nieaktywność), a nasz serwlet nie jest przygotowany do odtworzenia połączenia przy ew. kolejnym zleceniu,
• wreszcie, w tym programiku występuje znany nam już problem zmieszania kodu odpowiedzialnego za pracę i kodu prezentacji (na razie pominiemy to zagadnienie, aby było widać wyraźniej całościowe kody programów; później zajmiemy się przebudową właściwej aplikacji  w konwencji MVC),

 // Drugie wadliwe rozwiązanie
 
 public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
   resp.setContentType("text/html; charset=windows-1250");
   PrintWriter out = resp.getWriter();
   out.println("<h2>Lista dostępnych książek</h2>");

   Connection con;
   String sel = "select * from pozycje";
   try  {
      con = DriverManager.getConnection(...);

      Statement stmt = con.createStatement();
      ResultSet rs = stmt.executeQuery(sel);
      out.println("<ol>");
      while (rs.next())  {
        String tytul = rs.getString("tytul");
        float cena  = rs.getFloat("cena");
        out.println("<li>" + tytul + " - cena: " + cena + "</li>");
      }
      rs.close();
      stmt.close();
      con.close();
    } catch (Exception exc)  {
       out.println(exc.getMessage());
    }
    out.close();
  }

• w ramach elementu Resource: nazwę zasobu (tu nasza baza identyfikowana przez jdbc/ksidb), jego autoryzację - czyli kto będzie odpowiadał za rejestrację zasobu u manadżera zasobów (podając "Container" powiemy, że kontener serwletów, czyli część serwera, zajmującego się obsługą serwletów) , typ zasobu - czyli klasę jego obiektów - tu będzie to DataSource),
• w ramach elementu ResourceParams - paranetry tworzenia zasobu (w naszym przypadku - klasę sterownika JDBC, url zasobu, nazwę użytkownika, hasło).

<Context path="/db" docBase="E:/Programming/webaps/SERWLETY/db/build">

  <Resource name="jdbc/ksidb" auth="Container" 
            type="javax.sql.DataSource"
            description="Baza danych ksiazek" 
            driverClassName="org.apache.derby.jdbc.ClientDriver"
            url="jdbc:derby://localhost/ksidb"
            username="APP"
            password="APP"
            maxActive="20" /> 
</Context>

      Context init = new InitialContext();
      Context contx = (Context) init.lookup("java:comp/env");
      DataSource dataSource = (DataSource) contx.lookup("jdbc/ksidb");

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import javax.naming.*;
import java.sql.*;
import javax.sql.*;

public class DbServlet3 extends HttpServlet {

  DataSource dataSource;  // źrodło danych

  public void init() throws ServletException {
    try {
      Context init = new InitialContext();
      Context contx = (Context) init.lookup("java:comp/env");
      dataSource = (DataSource) contx.lookup("jdbc/ksidb");
     } catch (NamingException exc) {
        throw new ServletException(
          "Nie mogę uzyskać źródła java:comp/env/jdbc/ksidb", exc);
     }
  }

  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
    resp.setContentType("text/html; charset=windows-1250");
    PrintWriter out = resp.getWriter();
    out.println("<h2>Lista dostępnych książek</h2>");

    Connection con = null;
    try {
      synchronized (dataSource) {
        con = dataSource.getConnection();
      }
      Statement stmt = con.createStatement();
      ResultSet rs = stmt.executeQuery("select * from pozycje");
      out.println("<ol>");
      while (rs.next())  {
        String tytul = rs.getString("tytul");
        float cena  = rs.getFloat("cena");
        out.println("<li>" + tytul + " - cena: " + cena + "</li>");
      }
      rs.close();
      stmt.close();
    } catch (Exception exc)  {
       out.println(exc.getMessage());
    } finally {
        try { con.close(); } catch (Exception exc) {}
    }

    out.close();


  }


  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
                 throws ServletException, IOException
  {
      serviceRequest(request, response);
  }

}

import java.io.*;
import java.util.*;
import javax.naming.*;
import java.sql.*;
import javax.sql.*;

public class DbAccess extends CommandImpl {

  private DataSource dataSource;

  public void init() {
    try {
      Context init = new InitialContext();
      Context jndiCtx = (Context) init.lookup("java:comp/env");
      String dbName = (String) getParameter("dbName");
      dataSource = (DataSource) jndiCtx.lookup(dbName);
     } catch (NamingException exc) {
         setStatusCode(1);
     }
  }

  public void execute() {
    clearResult();
    setStatusCode(0);
    Connection con = null;
    try {
      synchronized(this) {
        con = dataSource.getConnection();
      }

      Statement stmt = con.createStatement();

      String cmd =  (String) getParameter("command");

      if (cmd.startsWith("select")) {
        ResultSet rs = stmt.executeQuery(cmd);

        // Będziemy zapisywać wynik jako skonkatenowane
        // wartości z kolumn ResultSetu
        // Oczywiście, w różnych kwerendach będą różne kolumny
        // zatem korzystamy z ResultSetMetaData, by do nich dotrzeć
 
        ResultSetMetaData rsmd = rs.getMetaData();
        int cols = rsmd.getColumnCount();
        while (rs.next()) {
          String wynik = "";
          for (int i=1; i<=cols; i++)
             wynik += rs.getObject(i) + " ";
          addResult(wynik);
        }
        rs.close();
      }
      else if (cmd.startsWith("insert")) {
        int upd = stmt.executeUpdate(cmd);
        addResult("Dopisano " + upd + " rekordów");
        }
      else setStatusCode(3);
    } catch (SQLException exc) {
          setStatusCode(2);
          throw new DbAccessException("Błąd w dostępie do bazy lub w SQL", exc);
    } finally {
        try {
          con.close();
        } catch (Exception exc) {}
    }
  }

}

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.text.*;

public class ControllerServ extends HttpServlet {

  private ServletContext context;
  private Command command;            // obiekt klasy dzialania (wykonawczej)
  private String presentationServ;    // nazwa serwlet prezentacji
  private String getParamsServ;       // mazwa serwletu pobierania parametrów

  public void init() {

    context = getServletContext();

    presentationServ = context.getInitParameter("presentationServ");
    getParamsServ = context.getInitParameter("getParamsServ");
    String commandClassName = context.getInitParameter("commandClassName");
    String dbName = context.getInitParameter("dbName");

    // Załadowanie klasy Command i utworzenie jej egzemplarza
    // który będzie wykonywał pracę
    try {
      Class commandClass = Class.forName(commandClassName);
      command = (Command) commandClass.newInstance();
      // ustalamy, na jakiej bazie ma działać Command i inicjujemy obiekt
      command.setParameter("dbName", dbName);
      command.init();
    } catch (Exception exc) {
        throw new NoCommandException("Couldn't find or instantiate " +
                                      commandClassName);
    }
  }

  // ... dalej znany już kod obsługi zleceń

import java.util.*;

public class DbAccessDef_pl extends ListResourceBundle {
     public Object[][] getContents() {
         return contents;
     }

    static final Object[][] contents = {
       { "charset", "ISO-8859-2" },
       { "header", new String[] { "Baza danych książek" } },
       { "param_command", "Polecenie (select lub insert):" },
       { "submit", "Wykonaj" },
       { "footer", new String[] { } },
       { "resCode", new String[]
                    { "Wynik:", "Brak bazy", "Błąd SQL",
                      "Wadliwe polecenie; musi zaczynać się od select lub insert" }
                    },
       { "resDescr",
            new String[] { "" } },
    };
}

public class DbAccessException extends RuntimeException {
  public DbAccessException(String msg, Throwable cause) {
     super(msg, cause);
   }
} 

 public void execute() {
   //....
   try {

     // łączenie z bazą i operacje na niej
     // ...
   } catch (SQLException exc) {
          setStatusCode(2);
          throw new DbAccessException("Błąd w dostępie do bazy lub w SQL", exc);
    } finally {
        try {
          con.close();
        } catch (Exception exc) {}
    }
  }

public class ErrorHandler extends HttpServlet {

  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
    String charset = BundleInfo.getCharset();
    resp.setContentType("text/html; charset=" + charset);
    Throwable exc = (Throwable)
                     req.getAttribute("javax.servlet.error.exception");

    if (exc != null) {
      PrintWriter out = resp.getWriter();
      out.println("<h2>" + exc.getMessage() + "</h2><hr>");
      Throwable cause = exc.getCause();
      if (cause instanceof SQLException) {
        SQLException sqlexc = (SQLException) cause;
        out.println(sqlexc.getMessage() + "<br><br>");
        out.println("Error code: " + sqlexc.getErrorCode() + "<br>");
        out.println("SQL state : " + sqlexc.getSQLState() + "<br>");
      }
      out.close();
    }

  }
//... metody doGet i doPost wołają serviceRequest

   // ...
   <servlet>
       <servlet-name>ErrorHandler</servlet-name>
       <servlet-class>ErrorHandler</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ErrorHandler</servlet-name>
        <url-pattern>/errorhandler</url-pattern>
    </servlet-mapping>

   <error-page>
     <exception-type>DbAccessException</exception-type>
     <location>/errorhandler</location>
   </error-page>
   //..

8. Cookies

public class CookieAndSess extends HttpServlet {

  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {

      resp.setContentType("text/html");
      PrintWriter out = resp.getWriter();

      Cookie[] cookies = req.getCookies();
      Cookie countCookie = null;
      HttpSession session = null;

      if (cookies != null) {
        for (int i=0; i<cookies.length; i++) {
          String name = cookies[i].getName();
          String value = cookies[i].getValue();
          out.println("<br>" + name + " " + value);
          if (name.equals("count")) {
            countCookie = cookies[i];
            int count = Integer.parseInt(countCookie.getValue()) + 1;
            countCookie.setValue(String.valueOf(count));
            if (count > 3) session = req.getSession();
            }
          }
        }
      if (session != null) {
        out.println("<hr>");
        out.println("Sesja: " + session.getId());
      }
      if (countCookie == null) countCookie = new Cookie("count", "1");
      resp.addCookie(countCookie);
      out.close();
  }

}

9. Słuchacze i filtry

1. wszystkie metody reagujące na inicjację (kontekstu, zlecenia, sesji) otrzymują sterowanie po inicjacji; wszystkie metody reagujące na deaktywację (kontekstu, zlecenia, sesji) otrzymują sterowanie tuż przed deaktywacją,
2. aktywacja/deaktywacja sesji oznacza przesunięcie jej do innej maszyny wirtualnej lub jej serializację/deserializację. HttpSessionActivationListener nie obsługuje zdarzeń tworzenia lub zamykania sesji.
   
3. zdarzenie HttpSessionBindingEvent jest posyłane do obsługi słuchaczowi HttpSessionAttributeListener, gdy jakikolwiek atrybut sesji ulega zmianie, natomiast do obsługi przez obiekt implementujący HttpSessionBindingListener gdy ten właśnie obiekt jest dowiązywany do sesji (metodą setAttribute) lub odwiązywany -  metodą removeAttribute()

    <listener>
        <listener-class>[nazwa_pakietu.]nazwa_klasy_słuchacza</listener-class>
    </listener>

<Context path="/jakas" ...>
  ...
  <Listener className="[nazwa_pakietu.]nazwa_klasy_słuchacza" ... >
  ...
</Context>

package listeners;
import java.util.*;

public class Report {
   private static List rep = new ArrayList();

   public static void add(String s) {
     rep.add(s);
   }

   public static List get() { return rep; }
}

package listeners;
import javax.servlet.*;

public class TestContextListener implements ServletContextListener{


  public void contextInitialized(ServletContextEvent p0) {
     Report.add("Kontekst utworzony");
     ServletContext context = p0.getServletContext();
     context.setAttribute("Liczba", new Integer(1));
  }

  public void contextDestroyed(ServletContextEvent p0) {
  }
}

import javax.servlet.*;

public class TestContextAttributeListener implements ServletContextAttributeListener{

  public void attributeAdded(ServletContextAttributeEvent p0) {
    Report.add("Do kontekstu dodano atrybut " + p0.getName() +
    " = " + p0.getValue());
  }

  public void attributeRemoved(ServletContextAttributeEvent p0) {
    Report.add("Z kontekstu usunięto atrybut " + p0.getName() +
    " = " + p0.getValue());
  }

  public void attributeReplaced(ServletContextAttributeEvent p0) {
    Report.add("W kontekście zmieniono atrybut " + p0.getName() +
    " = " + p0.getValue());
  }

}

package listeners;
import javax.servlet.http.*;

public class TestSesAttrListener implements HttpSessionAttributeListener{



  public void attributeAdded(HttpSessionBindingEvent p0) {
    Report.add("Do sesji dodany atrybut " + p0.getName() + " = " + p0.getValue());
  }

  public void attributeRemoved(HttpSessionBindingEvent p0) {
    Report.add("Z sesji usunięty atrybut " + p0.getName() + " = " + p0.getValue());
  }

  public void attributeReplaced(HttpSessionBindingEvent p0) {
    Report.add("Zmieniony sesji atrybut " + p0.getName() + " = " + p0.getValue());
  }
}

• getServletContext() z klasy ServletContextEvent zwraca kontekst aplikacji,
• getName() i getValue() z klas ServletContextAttributeEvent i HttpSessionBindingEvent zwracają nazwę i wartość atrybutu, którego dotyczy zdarzenie.

<?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-app_2_4.xsd">

    <display-name>Adds</display-name>
    <description>Dodatkowi słuchacze</description>

    <listener>
        <listener-class>listeners.TestContextListener</listener-class>
    </listener>
    <listener>
        <listener-class>listeners.TestContextAttributeListener</listener-class>
    </listener>
    <listener>
        <listener-class>listeners.TestSesAttrListener</listener-class>
    </listener>


    <servlet>
       <servlet-name>ListenersTest</servlet-name>
       <description></description>
       <servlet-class>ListenersTest</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ListenersTest</servlet-name>
        <url-pattern>/listen</url-pattern>
    </servlet-mapping>

</web-app>

package listeners;
import javax.servlet.http.*;

public class SwiadomyAtrybut  implements HttpSessionBindingListener{

  private String val;

  public SwiadomyAtrybut(String val) {
    this.val = val;
  }


  public void valueBound(HttpSessionBindingEvent p0) {
    Report.add("Jestem \"świadomym\" atrybutem " +
         p0.getName() + " i wiem, że własnie zostałem dodany do sesji");
  }

  public void valueUnbound(HttpSessionBindingEvent p0) {
    Report.add("Jestem \"świadomym\" atrybutem " +
         p0.getName() + " i wiem, że własnie zostałem usunięty z sesji");

  }

  public String toString() { return val; }
}

• ustalenie atrybutu do sesji.
• usunięcie atrybutu z sesji,
• ustalenie obiektu klasy SwiadomyAtrybut jakio atrybutu sesji,
• usuniecie go z zestawu atrybutów sesji,
• zmianę atrybutu kontekstu (ma ona nazwę "Liczba", jest ustalony na 1 przy tworzeniu kontekstu przez słuchacza kontekstu, po czym każdy wybór opcji "zmiana atrybutu" powoduje zwiększenie tej liczby o 1).

<form>
<p><input type="submit" name="setsesatt1" value="Normalny atrybut sesji (set)" style="background: white">
<p><input type="submit" name="remsesatt1" value="Usu˝ normalny atrybut sesji " style="background: white">
<p><input type="submit" name="setsesatt2" value="îwiadomy atrybut sesji (set)" style="background: white">
<p><input type="submit" name="remsesatt2" value="Usu˝ ťwiadomy atrybut sesji" style="background: white">
<p><input type="submit" name="chgatt" value="Zmien atrybut kontekstu" style="background: white">
</form>

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import listeners.Report;
import listeners.SwiadomyAtrybut;

public class ListenersTest extends HttpServlet {

  static int count = 0;  // dla zmian "Liczby" - atrybutu kontekstu


  SwiadomyAtrybut sa = new SwiadomyAtrybut(
                       "jestem atrybutem, co wie kiedy go dodają lub usuwają"
                       );


  public void init() {
    Report.add("Inicjacja serwletu");
  }

  public void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
      resp.setContentType("text/html; charset=windows-1250");
      PrintWriter out = resp.getWriter();
      out.println("<center><h2>Testowanie słuchaczy</h2></center>");
      req.getRequestDispatcher("form.html").include(req,resp);

      HttpSession ses = req.getSession();
      if (req.getParameter("setsesatt1") != null) {
          Report.add("<b><i>--- wybrano 'Normalny atrybut sesji (set)'</b></i>");
          ses.setAttribute("atr_ses1", "jestem zwykłym atrybutem sesji");
      }
      else if (req.getParameter("remsesatt1") != null) {
        Report.add("<b><i>--- wybrano 'Usuń normalny atrybut sesji'</b></i>");
          ses.removeAttribute("atr_ses1");
      }
      else if (req.getParameter("setsesatt2") != null) {
        Report.add("<b><i>--- wybrano 'Świadomy atrybut sesji (set)'</b></i>");
        ses.setAttribute("atr_ses2", sa);
      }
      else if (req.getParameter("remsesatt2") != null) {
        Report.add("<b><i>--- wybrano 'Usuń świadomy atrybut sesji'</b></i>");
        ses.removeAttribute("atr_ses2");
      }
      else if (req.getParameter("chgatt") != null) {
        count++;
        if (count > 1) {
           Report.add("<b><i>--- wybrano 'Zmień atrybut kontekstu'</b></i>");
           getServletContext().setAttribute("Liczba", new Integer(count));
        }
      }

      out.println("<hr>");
      out.println("<u>Co się działo ?</u>");
      List list = Report.get();
      out.println("<ol>");
      for (Iterator it = list.iterator(); it.hasNext(); ) {
        out.println("<li>" + it.next() + "</li>");
      }
      out.println("</ol>");
      out.close();
  }
}

1. Kontekst utworzony
2. Do kontekstu dodano atrybut Liczba = 1
3. Inicjacja serwletu
4. --- wybrano 'Normalny atrybut sesji (set)'
5. Do sesji dodany atrybut atr_ses1 = jestem zwykłym atrybutem sesji
6. --- wybrano 'Świadomy atrybut sesji (set)'
7. Jestem "świadomym" atrybutem atr_ses2 i wiem, że własnie zostałem dodany do sesji
8. Do sesji do dany atrybut atr_ses2 = jestem atrybutem, co wie kiedy go dodają lub usuwają
9. --- wybrano 'Usuń normalny atrybut sesji'
10. Z sesji usunięty atrybut atr_ses1 = jestem zwykłym atrybutem sesji
11. --- wybrano 'Usuń świadomy atrybut sesji'
12. Jestem "świadomym" atrybutem atr_ses2 i wiem, że własnie zostałem usunięty z sesji
13. Z sesji usunięty atrybut atr_ses2 = jestem atrybutem, co wie kiedy go dodają lub usuwają
14. --- wybrano 'Zmień atrybut kon tekstu'
15. W kontekście zmieniono atrybut Liczba = 1
16. --- wybrano 'Zmień atrybut kontekstu'
17. W kontekście zmieniono atrybut Liczba = 2

• doFilter - w której wykonujemy działania związane z analizą zlecenia i ew. jego blokowaniem lub modyfikacją (w szcególności nagłówków),  a także ew. modyfikacji odpowiedzi generowanych przez WEB-komponenty, do których zlecenie jest kierowane,
• init - która jest wolana zaraz po utworzeniu obiektu-filtra i m.in. pozwala pobrać inicjalne parametry dla filtra
• destroy - wołana przed usunięciem filtra, pozwla na wykonanie prac porządkowych (np. zwolnienie zasobów alokowanych przez filtr)

• obiekt-zlecenie (ServletRequest)
• obiekt-odpowiedż (ServletResponse)
• łańcuch filtrów (FilterChain)

package filters;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

public class TestFilter implements Filter{

  private static int ind = 0;  // indeks ogłoszenia

  // szablon ogłoszenia
  private String szablon =
  "<table cellpadding=\"2\" cellspacing=\"2\" border=\"1\" width=\"100%\">"+
  "<tbody><tr><td valign=\"Top\" bgcolor=\"#000099\">" +
  "<div align=\"Center\"><font color=\"#ffffff\">@</font></div></td>"+
  "</tr></tbody></table>";

  // Lista ogłoszeń
  private List oglosz = new  ArrayList();

  // Tablica kodowań dla różnych "locale"
  private Properties encodings = new Properties();

  public void init(FilterConfig fc) throws ServletException {

    ServletContext sc = fc.getServletContext();

    // Strumień dla tablicy kodowań
    InputStream props = sc.getResourceAsStream("WEB-INF/encodings.properties");
    try {
      // załadowanie tablicy kodowań
      if (props != null) encodings.load(props);

      // Plik z ogłoszeniami
      InputStream is = sc.getResourceAsStream("WEB-INF/ogloszenia.txt");
      BufferedReader br = new BufferedReader(
                          new InputStreamReader(is)
                          );
      String line;
      while ((line = br.readLine()) != null) oglosz.add(line);
      br.close();
    } catch (Exception exc) { oglosz.add("Witamy!"); }
  }


  public void doFilter(ServletRequest req, ServletResponse resp,
                       FilterChain chain)
                       throws IOException,ServletException
  {
    // Ustalenie kolejnego ogłoszenia
    String msg;
    synchronized(this) {
      msg = szablon.replaceFirst("@", (String) oglosz.get(ind));
      if (ind < oglosz.size() - 1) ind++;
      else ind = 0;
    }

    // Ustalenie kodowania
    Locale locale =  req.getLocale();
    String charset = (String) encodings.get(locale);
    if (charset == null) charset = "windows-1250";
    resp.setContentType("text/html; charset=" + charset);

    // Generacja początku strony
    PrintWriter out = ((HttpServletResponse) resp).getWriter();
    out.println(msg);

    // Wywołanie następnego elementu FilterChain
    // zwykle już bezpośrednio serwletu

    chain.doFilter(req, resp);
  }

  public void destroy() {

  }
}

• od FilterConfig (parametr metody init()) można pobrać kontekst apliakacji i za jego pomocą uzyskać dostęp do zasobow (jak to robimy w powyższym programie) lub np. ystalić jakieś atrybuty kontekstu - do wykorzystania przez inne filtry lub serwlety w łańcuchu,
• programując filtry musimy pamiętac o synchronizacji; tak samo jak serwlety dostęp do obiektów-filtrów może mieć równocześnie wiele wątków (w naszym przykłądzie synchronizujemy podstawienie ogłoszenia do szablonu oraz zmianę indeksu ogłoszenia).

    <filter>
        <filter-name>HeaderFilter</filter-name>
        <filter-class>filters.TestFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>HeaderFilter</filter-name>
        <url-pattern>/go</url-pattern>
    </filter-mapping>

    <filter-mapping>
        <filter-name>HeaderFilter</filter-name>
        <url-pattern>/go</url-pattern>
    </filter-mapping>

    <filter-mapping>
        <filter-name>HeaderFilter</filter-name>
        <url-pattern>/run</url-pattern>
    </filter-mapping>

    <filter>
        <filter-name>HeaderFilter</filter-name>
        <filter-class>filters.TestFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HeaderFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

<?xml version="1.0" encoding="UTF-8"?>
  <web-app version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-app_2_4.xsd">

    <display-name>Adds</display-name>
    <description>Dodatkowe</description>

    <filter>
        <filter-name>HeaderFilter</filter-name>
        <filter-class>filters.TestFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HeaderFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <listener>
        <listener-class>listeners.TestContextListener</listener-class>
    </listener>
    <listener>
        <listener-class>listeners.TestContextAttributeListener</listener-class>
    </listener>
    <listener>
        <listener-class>listeners.TestSessionListener</listener-class>
    </listener>
    <listener>
        <listener-class>listeners.TestSesAttrListener</listener-class>
    </listener>



    <servlet>
       <servlet-name>CookieAndSess</servlet-name>
       <description></description>
       <servlet-class>CookieAndSess</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>CookieAndSess</servlet-name>
        <url-pattern>/cook</url-pattern>
    </servlet-mapping>

    <servlet>
       <servlet-name>ListenersTest</servlet-name>
       <description></description>
       <servlet-class>ListenersTest</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ListenersTest</servlet-name>
        <url-pattern>/listen</url-pattern>
    </servlet-mapping>

</web-app>

• odziedziczyć HttpServletResponseWrapper,
• w konstruktorze z argumentem HttpServletResponse wyowłać konstruktor nadklasy przekazują ten argument (oryginalną odpowiedź),
• przedefiniować te metody klasy, dla których chcemy dostarczyć własnej funkcjonalności, w szczeglności np. podmiany strumienia do którego mają pisać swoją odpowiedź serwlety na nasz własny strumień, który w filtrze będziemy mogli odczytać i dzieki temu zmodyfikować treść odpowiedzi przekazywanej dalej, z powrotem po łąńcuchu filtrów.

package filters;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;


public class StringResponseWrapper extends HttpServletResponseWrapper {

  // Strumien do którego będą pisane odpowiedzi
  private StringWriter stringWriter = null;

  public StringResponseWrapper(HttpServletResponse response) {
    super(response);
  }

  // Przedefiniowanie metody getWriter()
  // każdy kto ejj użyje - otrzyma nasz strumień StringWriter
  // i nic o tym nie wiedząc będzie pisał do niego
  // a nie do strumienia
  // związanego z oryginalnym obiektem HttpServletResponse


  public PrintWriter getWriter() throws IOException {
    if (stringWriter == null) stringWriter = new StringWriter();
    return new PrintWriter(stringWriter);
  }

  // Nie jesteśmy przygotowani na obsługę strumieni binarnych
  // - wykluczamy ich zastosowanie (chociaż nie musimy tego robić)

  public ServletOutputStream getOutputStream() throws IOException {
    throw new IllegalStateException(
      "getOutputStream() not allowed for StringResponseWrapper"
      );
  }

  // Nasza własna metoda, pozwlająca uzyskać dostęp do strumioenia
  // i do jego zawartości

  public StringWriter getStringWriter() {
    return stringWriter;
  }

}

import javax.servlet.*;
import javax.servlet.http.*;

public class FooterFilter implements Filter{

  public void init(FilterConfig p0) throws ServletException {
  }

  public void doFilter(ServletRequest req, ServletResponse resp,
                       FilterChain chain) throws IOException,ServletException {

    Locale locale = req.getLocale();
    StringResponseWrapper newResp = new StringResponseWrapper(
                                        (HttpServletResponse) resp
                                     );
    chain.doFilter(req, newResp);
    StringWriter sw = newResp.getStringWriter();

    // Uzyskujemy treść wygenrowanej odpowiedzi
    String cont = sw.toString();

    // Teraz możemy zrobić cokolwiek z odpowiedzią
    // tu tylko dopiszemy do niej "stopkę"

    // Bierzemy strumień oryginalnej odpowiedzi
    PrintWriter out = resp.getWriter();

    // Przepisujemy otrzymaną odpowiedź
    out.println(cont);

    // Dopisujemy stopkę
    DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG,
                                                   DateFormat.MEDIUM,
                                                   locale);

    out.println("<hr><i><b>" + df.format(new Date()) + "</i></b>");
    out.close();
  }

  public void destroy() {
  }
}

    <filter>
        <filter-name>HeaderFilter</filter-name>
        <filter-class>filters.TestFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HeaderFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter>
        <filter-name>FooterFilter</filter-name>
        <filter-class>filters.FooterFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>FooterFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

• tak samo jak odpowiedzi, również zlecenia (HttpServletRequest) możemy w filtrach modyfikować, opakowując je obiektami własnych klas dziedizczących HttpServletRequestWrapper,
• zablokowanie dostepu przez filtr jest bardzo proste - wystarczy nie wyowłać metody doFilter łańcucha filtrów, a zamiast tego dostarczyć jako odpowiedzi jakiejś strony z wyjaśneiniem dlaczego dostep jest zabroniony; zwykle będzie to zależeć od jakichś warunków, które możemy sprawdzić analizując zlecenie (np. host skąd prztszło), od identyfikacji użytkownika, jakichś parametrów czasowych,
• filtry mogą przekierowywac zlecenia (np. tymczasowo jakieś komponenty są wyłączone z pracy, zlecenia do nich mogą przekierowane do stron informacyjnych lub innych komponentów zastępczych),
• filtry i opakowania zleceń i odpowiedzi  można budować w ogólniejszy niż pokazano sposób, np. uzwględniając inne niż HTPP protokoły (dlatego parametry metody doFilter mają ogólniejsze typy: ServletRequest i ServletResponse) czy też - oprócz strumieni znakowych - również strumienie binarne (uzyskiwane np. w serwletach przez getOutputStream()).

10. Rozszerzerzenia serwletów: Java Server Pages i Java Server Faces (syntetyczna informacja)

• wymaga znajomości Javy do przygotowania prezentacyjnej czesci aplikacji (a często taką prezentacją zajmują sie ludzie nie znający programowania),
• wymaga  rekompilacji serwletu przy zmianie sposobu prezentacji treści.

• dyrektywy - zapisywane w znacznikach   < %@  ....       % >  - dotyczą całej strony opisują sposób jej translacji i wykonania przez serwer
• elementy skryptowe:
• deklaracje      < %!  ....     %  >  deklaracje zmiennych,obiektów i metod
• wyrażenia      <%=  ....       %>  wartości wyrażeń zwracane przez serwer (zwykle dotyczą informacji uzyskiwanych od kontekstu aplikacji, zlecenia itp.,  niejako erplikują znane nam metody klas ServletContext, HttpRequest, HttpSession itp.)
• skryplety       <%   ....        %>  frgamenty kodu w  Javie
• akcje - oznaczane tagami   < jsp: ...       / > m.in.
• <jsp:useBean... />      - tworzenie obiektu JavaBean
• <jsp:setProperty... />  - ustalenie właściwosci JavaBean
• <jsp:getProperty... />  - pobranie właściwości JavaBean
• <jsp:include|forward..> - użycie RequestDispatchera do włączenia inengo kompoenetu WEB lub przekazania sterowania do innego kompoenntu WEB
• elementy języka wyrażeń (EL) - wyrażenia zapisane w znacznikach ${...}-  pozwalają m.in. wykonywać obliczenia i w latwy sposób odwoływać się do właściwości JavaBeans
• definiowane znaczniki - własne znaczniki, niejako własne rozszerzenia języka JSP, dostarczane w bibliotekach znaczników (taglibs), które wiążą elementy-znaczniki z obiektami, które definiują i implementują ich funkcjonalność.

Np. gdy chcemy użyć bazowych znaczników (Core) piszemy:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" 
    prefix="c" %>

<%--
 Znacznik wpisujący podany jako atrybut msg tekst
 poprzedzony jakąś (nieobowiązkową) informacją
--%>
<%@ attribute name="pre" required="false"%>
<%@ attribute name="info" required="true"%>
<h2>${pre}<br>${info}</h2>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<%@ taglib tagdir="/WEB-INF/tags" prefix="m" %>

<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=windows-1250">
  <title>Test</title>
</head>
<c:set var="fmsg" value="Wprowadź informację" />
<c:set var="preinfo" value="Wprowadziłeś:" />
<h2>Aplikacja testowa<br>${fmsg}</h2>

<form>
<input type="text" name="info" size="50">
<p></p>
<input type="submit" value="Submit">
<input type="reset" value="Reset">
</form>

<c:if test="${fn:length(param.info) > 0}" >
  <m:msg pre="${preinfo}" info="${param.info}"/>
</c:if>
</body>
</html>

• tagi są poprzedzane prefiksami dla właściwych bibliotek,
• set z Core JSTL ustala wartości zmiennych
• w języku wyrażeń EL możemy się do nich odwoływać przez ${nazwa_zmiennej}
• do parametrów zlecenia odwołujemy się przez param.nazwa_parametru,

  <servlet>
    <display-name>dialog</display-name>
    <servlet-name>dialog</servlet-name>
    <jsp-file>/dialog.jsp</jsp-file>
  </servlet>

  <servlet-mapping>
    <servlet-name>dialog</servlet-name>
    <url-pattern>/first</url-pattern>
  </servlet-mapping>

• c:forEach - pozwala na przebieganie tablic i  - uwaga - dowolnych kolekcji
• sql:query - pozwala na posylanie kwerend do baz danych,

• reprezentacji komponemtów UI w sposób niezależny od modeli danych
• obsługi zdarzeń,
• walidacji danych po stronie serwera,
• konwersji danych
• nawigacji pomiędzy stronami (html, jsp, serwletami),
• internacjoonalizacji treści,
• oraz dowolnych rozszerzeń tych funkcji,

11. Zadania i ćwiczenia

1. Zainstalować i przetestowac wszystkie apliakcje tego rozdziału.
2. Napisać aplikację WEB, która po przedstawieniu tytułów książek z bazy książek pozwala na wybór książki i pokazanie szczegółowej informacji o niej (autor, isbn, cena). Przygotować dwie wersje tej aplikacji: z wykorzystaniem i bez wykorzystania JSP.
3. Napisać apliakcję WEB, która służy do przeprowadzania testów z języka Java. Użyć narzędzi bazodanowych.