Servlet - Guida rapida

Cosa sono i servlet?

I Java Servlet sono programmi che vengono eseguiti su un server Web o di applicazioni e fungono da livello intermedio tra le richieste provenienti da un browser Web o da un altro client HTTP e database o applicazioni sul server HTTP.

Utilizzando i servlet, è possibile raccogliere input dagli utenti tramite moduli di pagine Web, presentare record da un database o da un'altra fonte e creare pagine Web dinamicamente.

I Java Servlet spesso hanno lo stesso scopo dei programmi implementati utilizzando Common Gateway Interface (CGI). Ma i servlet offrono diversi vantaggi rispetto al CGI.

  • Le prestazioni sono notevolmente migliori.

  • I servlet vengono eseguiti nello spazio degli indirizzi di un server Web. Non è necessario creare un processo separato per gestire ogni richiesta del client.

  • I servlet sono indipendenti dalla piattaforma perché sono scritti in Java.

  • Java Security Manager sul server applica una serie di restrizioni per proteggere le risorse su una macchina server. Quindi i servlet sono affidabili.

  • La piena funzionalità delle librerie di classi Java è disponibile per un servlet. Può comunicare con applet, database o altri software tramite i socket ei meccanismi RMI che hai già visto.

Architettura dei servlet

Il diagramma seguente mostra la posizione dei servlet in un'applicazione Web.

Attività dei servlet

I servlet eseguono le seguenti attività principali:

  • Leggere i dati espliciti inviati dai client (browser). Ciò include un modulo HTML su una pagina Web o potrebbe anche provenire da un'applet o da un programma client HTTP personalizzato.

  • Leggere i dati della richiesta HTTP implicita inviati dai client (browser). Ciò include cookie, tipi di media e schemi di compressione che il browser comprende e così via.

  • Elaborare i dati e generare i risultati. Questo processo può richiedere la comunicazione con un database, l'esecuzione di una chiamata RMI o CORBA, il richiamo di un servizio Web o l'elaborazione diretta della risposta.

  • Invia i dati espliciti (ovvero il documento) ai client (browser). Questo documento può essere inviato in una varietà di formati, inclusi testo (HTML o XML), binario (immagini GIF), Excel, ecc.

  • Invia la risposta HTTP implicita ai client (browser). Ciò include dire ai browser o ad altri client quale tipo di documento viene restituito (ad esempio, HTML), impostare cookie e parametri di memorizzazione nella cache e altre attività simili.

Pacchetti servlet

I Java Servlet sono classi Java eseguite da un server web che dispone di un interprete che supporta la specifica Java Servlet.

I servlet possono essere creati utilizzando il javax.servlet e javax.servlet.http packages, che sono una parte standard dell'edizione enterprise di Java, una versione espansa della libreria di classi Java che supporta progetti di sviluppo su larga scala.

Queste classi implementano le specifiche Java Servlet e JSP. Al momento della stesura di questo tutorial, le versioni sono Java Servlet 2.5 e JSP 2.1.

I servlet Java sono stati creati e compilati proprio come qualsiasi altra classe Java. Dopo aver installato i pacchetti servlet e averli aggiunti al Classpath del computer, è possibile compilare servlet con il compilatore Java di JDK o qualsiasi altro compilatore corrente.

Cosa c'è dopo?

Ti porterei passo dopo passo a configurare il tuo ambiente per iniziare con Servlet. Quindi allaccia la cintura per una bella guida con Servlet. Sono sicuro che apprezzerai molto questo tutorial.

Un ambiente di sviluppo è il luogo in cui dovresti sviluppare il tuo Servlet, testarlo e infine eseguirlo.

Come qualsiasi altro programma Java, è necessario compilare un servlet utilizzando il compilatore Java javac e dopo la compilazione dell'applicazione servlet, sarebbe distribuita in un ambiente configurato per testare ed eseguire ..

Questa configurazione dell'ambiente di sviluppo prevede i seguenti passaggi:

Configurazione di Java Development Kit

Questo passaggio prevede il download di un'implementazione del Java Software Development Kit (SDK) e l'impostazione appropriata della variabile di ambiente PATH.

È possibile scaricare SDK dal sito Java di Oracle - Download di Java SE .

Dopo aver scaricato l'implementazione Java, segui le istruzioni fornite per installare e configurare l'installazione. Infine impostare le variabili di ambiente PATH e JAVA_HOME in modo che facciano riferimento alla directory che contiene java e javac, tipicamente java_install_dir / bin e java_install_dir rispettivamente.

Se stai utilizzando Windows e hai installato l'SDK in C: \ jdk1.8.0_65, inserirai la seguente riga nel tuo file C: \ autoexec.bat.

set PATH = C:\jdk1.8.0_65\bin;%PATH% 
set JAVA_HOME = C:\jdk1.8.0_65

In alternativa, su Windows NT / 2000 / XP, puoi anche fare clic con il pulsante destro del mouse su Risorse del computer, selezionare Proprietà, quindi Avanzate, quindi Variabili d'ambiente. Quindi, si aggiorna il valore PATH e si preme il pulsante OK.

Su Unix (Solaris, Linux, ecc.), Se l'SDK è installato in /usr/local/jdk1.8.0_65 e si utilizza la shell C, inserire quanto segue nel file .cshrc.

setenv PATH /usr/local/jdk1.8.0_65/bin:$PATH 
setenv JAVA_HOME /usr/local/jdk1.8.0_65

In alternativa, se utilizzi un IDE (Integrated Development Environment) come Borland JBuilder, Eclipse, IntelliJ IDEA o Sun ONE Studio, compila ed esegui un semplice programma per confermare che l'IDE sa dove hai installato Java.

Configurazione del server Web - Tomcat

Sul mercato sono disponibili numerosi server Web che supportano i servlet. Alcuni server web sono scaricabili gratuitamente e Tomcat è uno di questi.

Apache Tomcat è un'implementazione software open source delle tecnologie Java Servlet e Java Server Pages e può fungere da server autonomo per testare i servlet e può essere integrato con Apache Web Server. Ecco i passaggi per configurare Tomcat sulla tua macchina:

  • Scarica l'ultima versione di Tomcat da https://tomcat.apache.org/.

  • Dopo aver scaricato l'installazione, decomprimere la distribuzione binaria in una posizione comoda. Ad esempio in C: \ apache-tomcat-8.0.28 su Windows o /usr/local/apache-tomcat-8.0.289 su Linux / Unix e creare la variabile di ambiente CATALINA_HOME che punta a queste posizioni.

Tomcat può essere avviato eseguendo i seguenti comandi sulla macchina Windows:

%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-8.0.28\bin\startup.bat

Tomcat può essere avviato eseguendo i seguenti comandi su una macchina Unix (Solaris, Linux, ecc.) -

$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-8.0.28/bin/startup.sh

Dopo l'avvio, le applicazioni Web predefinite incluse con Tomcat saranno disponibili visitando http://localhost:8080/. Se tutto va bene, dovrebbe essere visualizzato il seguente risultato:

Ulteriori informazioni sulla configurazione e l'esecuzione di Tomcat sono disponibili nella documentazione inclusa qui, nonché sul sito Web di Tomcat - http://tomcat.apache.org

Tomcat può essere arrestato eseguendo i seguenti comandi sulla macchina Windows:

C:\apache-tomcat-8.0.28\bin\shutdown

Tomcat può essere arrestato eseguendo i seguenti comandi su una macchina Unix (Solaris, Linux, ecc.) -

/usr/local/apache-tomcat-8.0.28/bin/shutdown.sh

Configurazione di CLASSPATH

Poiché i servlet non fanno parte della piattaforma Java, Standard Edition, è necessario identificare le classi servlet nel compilatore.

Se utilizzi Windows, devi inserire le seguenti righe nel tuo file C: \ autoexec.bat.

set CATALINA = C:\apache-tomcat-8.0.28 
set CLASSPATH = %CATALINA%\common\lib\servlet-api.jar;%CLASSPATH%

In alternativa, su Windows NT / 2000 / XP, puoi andare su Risorse del computer -> Proprietà -> Avanzate -> Variabili d'ambiente. Quindi, si aggiorna il valore CLASSPATH e si preme il pulsante OK.

Su Unix (Solaris, Linux, ecc.), Se si utilizza la shell C, inserire le seguenti righe nel file .cshrc.

setenv CATALINA = /usr/local/apache-tomcat-8.0.28
setenv CLASSPATH $CATALINA/common/lib/servlet-api.jar:$CLASSPATH

NOTE - Supponendo che la tua directory di sviluppo sia C: \ ServletDevel (Windows) o / usr / ServletDevel (Unix), dovresti aggiungere anche queste directory in CLASSPATH in modo simile a quanto hai aggiunto sopra.

Un ciclo di vita di un servlet può essere definito come l'intero processo dalla sua creazione fino alla distruzione. I seguenti sono i percorsi seguiti da un servlet.

  • Il servlet viene inizializzato chiamando il init() metodo.

  • Il servlet chiama service() metodo per elaborare la richiesta di un cliente.

  • Il servlet viene terminato chiamando il destroy() metodo.

  • Infine, servlet è garbage raccolto dal garbage collector della JVM.

Parliamo ora in dettaglio dei metodi del ciclo di vita.

Il metodo init ()

Il metodo init viene chiamato solo una volta. Viene chiamato solo quando viene creato il servlet e non viene richiamato successivamente per alcuna richiesta dell'utente. Quindi, viene utilizzato per inizializzazioni una tantum, proprio come con il metodo init degli applet.

Il servlet viene normalmente creato quando un utente richiama per la prima volta un URL corrispondente al servlet, ma è anche possibile specificare che il servlet venga caricato al primo avvio del server.

Quando un utente richiama un servlet, viene creata una singola istanza di ogni servlet, con ogni richiesta dell'utente che risulta in un nuovo thread che viene passato a doGet o doPost a seconda dei casi. Il metodo init () crea o carica semplicemente alcuni dati che verranno utilizzati per tutta la vita del servlet.

La definizione del metodo init ha questo aspetto:

public void init() throws ServletException {
   // Initialization code...
}

Il metodo service ()

Il metodo service () è il metodo principale per eseguire l'attività effettiva. Il contenitore servlet (cioè il server web) chiama il metodo service () per gestire le richieste provenienti dal client (browser) e per riscrivere la risposta formattata al client.

Ogni volta che il server riceve una richiesta per un servlet, il server genera un nuovo thread e chiama il servizio. Il metodo service () controlla il tipo di richiesta HTTP (GET, POST, PUT, DELETE, ecc.) E chiama i metodi doGet, doPost, doPut, doDelete, ecc. Come appropriato.

Ecco la firma di questo metodo:

public void service(ServletRequest request, ServletResponse response) 
   throws ServletException, IOException {
}

Il metodo service () viene chiamato dal container e il metodo service richiama i metodi doGet, doPost, doPut, doDelete, ecc. Come appropriato. Quindi non hai nulla a che fare con il metodo service () ma sovrascrivi doGet () o doPost () a seconda del tipo di richiesta che ricevi dal client.

DoGet () e doPost () sono i metodi utilizzati più di frequente in ogni richiesta di servizio. Ecco la firma di questi due metodi.

Il metodo doGet ()

Una richiesta GET risulta da una normale richiesta di un URL o da un modulo HTML che non ha un METODO specificato e dovrebbe essere gestita dal metodo doGet ().

public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
   // Servlet code
}

Il metodo doPost ()

Una richiesta POST risulta da un modulo HTML che elenca specificamente POST come METHOD e dovrebbe essere gestita dal metodo doPost ().

public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
   // Servlet code
}

Il metodo destroy ()

Il metodo destroy () viene chiamato solo una volta alla fine del ciclo di vita di un servlet. Questo metodo offre al servlet la possibilità di chiudere le connessioni al database, arrestare i thread in background, scrivere elenchi di cookie o conteggi di visite su disco ed eseguire altre attività di pulizia simili.

Dopo che il metodo destroy () è stato chiamato, l'oggetto servlet viene contrassegnato per la garbage collection. La definizione del metodo di distruzione è simile a questa:

public void destroy() {
   // Finalization code...
}

Diagramma di architettura

La figura seguente mostra un tipico scenario del ciclo di vita di un servlet.

  • Per prima cosa le richieste HTTP in arrivo al server vengono delegate al contenitore servlet.

  • Il contenitore servlet carica il servlet prima di invocare il metodo service ().

  • Quindi il contenitore servlet gestisce più richieste generando più thread, ogni thread esegue il metodo service () di una singola istanza del servlet.

I servlet sono classi Java che servono le richieste HTTP e implementano il javax.servlet.Servletinterfaccia. Gli sviluppatori di applicazioni Web in genere scrivono servlet che estendono javax.servlet.http.HttpServlet, una classe astratta che implementa l'interfaccia Servlet ed è appositamente progettata per gestire le richieste HTTP.

Codice d'esempio

Di seguito è riportata la struttura del codice sorgente di esempio di un esempio di servlet per mostrare Hello World -

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

// Extend HttpServlet class
public class HelloWorld extends HttpServlet {
 
   private String message;

   public void init() throws ServletException {
      // Do required initialization
      message = "Hello World";
   }

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");

      // Actual logic goes here.
      PrintWriter out = response.getWriter();
      out.println("<h1>" + message + "</h1>");
   }

   public void destroy() {
      // do nothing.
   }
}

Compilazione di un servlet

Creiamo un file con il nome HelloWorld.java con il codice mostrato sopra. Posiziona questo file in C: \ ServletDevel (in Windows) o in / usr / ServletDevel (in Unix). Questa posizione del percorso deve essere aggiunta a CLASSPATH prima di procedere ulteriormente.

Supponendo che il tuo ambiente sia configurato correttamente, entra ServletDevel directory e compilare HelloWorld.java come segue:

$ javac HelloWorld.java

Se il servlet dipende da altre librerie, è necessario includere anche quei file JAR nel CLASSPATH. Ho incluso solo il file JAR servlet-api.jar perché non sto utilizzando nessun'altra libreria nel programma Hello World.

Questa riga di comando utilizza il compilatore javac integrato fornito con JDK (Java Software Development Kit) di Sun Microsystems. Affinché questo comando funzioni correttamente, è necessario includere la posizione dell'SDK Java che si sta utilizzando nella variabile di ambiente PATH.

Se tutto va bene, la compilazione di cui sopra produrrebbe HelloWorld.classfile nella stessa directory. La prossima sezione spiegherebbe come un servlet compilato verrebbe distribuito in produzione.

Distribuzione servlet

Per impostazione predefinita, un'applicazione servlet si trova nel percorso <Tomcat-installationdirectory> / webapps / ROOT e il file di classe risiederebbe in <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.

Se hai un nome di classe completo di com.myorg.MyServlet, quindi questa classe servlet deve trovarsi in WEB-INF / classes / com / myorg / MyServlet.class.

Per ora, copiamo HelloWorld.class in <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes e creiamo le seguenti voci in web.xml file situato in <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /

<servlet>
   <servlet-name>HelloWorld</servlet-name>
   <servlet-class>HelloWorld</servlet-class>
</servlet>

<servlet-mapping>
   <servlet-name>HelloWorld</servlet-name>
   <url-pattern>/HelloWorld</url-pattern>
</servlet-mapping>

Voci sopra da creare all'interno dei tag <web-app> ... </web-app> disponibili nel file web.xml. Potrebbero esserci varie voci in questa tabella già disponibili, ma non importa.

Hai quasi finito, ora avvia il server Tomcat usando <Tomcat-installationdirectory> \ bin \ startup.bat (su Windows) o <Tomcat-installationdirectory> /bin/startup.sh (su Linux / Solaris ecc.) E infine digita http://localhost:8080/HelloWorldnella casella degli indirizzi del browser. Se tutto va bene, otterrai il seguente risultato

Devi esserti imbattuto in molte situazioni in cui devi passare alcune informazioni dal tuo browser al server web e, infine, al tuo programma di backend. Il browser utilizza due metodi per passare queste informazioni al server web. Questi metodi sono il metodo GET e il metodo POST.

Metodo GET

Il metodo GET invia le informazioni utente codificate aggiunte alla richiesta della pagina. La pagina e le informazioni codificate sono separate dal? (punto interrogativo) come segue:

http://www.test.com/hello?key1 = value1&key2 = value2

Il metodo GET è il metodo predefinito per passare le informazioni dal browser al server web e produce una lunga stringa che appare nella casella Posizione: del browser. Non utilizzare mai il metodo GET se si dispone di password o altre informazioni riservate da passare al server. Il metodo GET ha limiti di dimensione: è possibile utilizzare solo 1024 caratteri in una stringa di richiesta.

Queste informazioni vengono passate utilizzando l'intestazione QUERY_STRING e saranno accessibili tramite la variabile d'ambiente QUERY_STRING e Servlet gestisce questo tipo di richieste utilizzando doGet() metodo.

Metodo POST

Un metodo generalmente più affidabile per passare informazioni a un programma di backend è il metodo POST. Questo impacchetta le informazioni esattamente allo stesso modo del metodo GET, ma invece di inviarle come stringa di testo dopo un? (punto interrogativo) nell'URL lo invia come messaggio separato. Questo messaggio arriva al programma di backend sotto forma di input standard che puoi analizzare e utilizzare per la tua elaborazione. Servlet gestisce questo tipo di richieste utilizzandodoPost() metodo.

Lettura dei dati del modulo utilizzando Servlet

I servlet gestiscono automaticamente l'analisi dei dati dei moduli utilizzando i seguenti metodi a seconda della situazione:

  • getParameter() - Chiami il metodo request.getParameter () per ottenere il valore di un parametro del form.

  • getParameterValues() - Chiama questo metodo se il parametro appare più di una volta e restituisce più valori, ad esempio la casella di controllo.

  • getParameterNames() - Chiama questo metodo se desideri un elenco completo di tutti i parametri nella richiesta corrente.

Esempio di metodo GET utilizzando URL

Ecco un semplice URL che passerà due valori al programma HelloForm utilizzando il metodo GET.

http://localhost:8080/HelloForm?first_name = ZARA&last_name = ALI

Di seguito è riportato il file HelloForm.javaprogramma servlet per gestire l'input fornito dal browser web. UseremogetParameter() metodo che rende molto facile accedere alle informazioni passate -

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

// Extend HttpServlet class
public class HelloForm extends HttpServlet {
 
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");

      PrintWriter out = response.getWriter();
      String title = "Using GET Method to Read Form Data";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
         
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<ul>\n" +
                  "  <li><b>First Name</b>: "
                  + request.getParameter("first_name") + "\n" +
                  "  <li><b>Last Name</b>: "
                  + request.getParameter("last_name") + "\n" +
               "</ul>\n" +
            "</body>" +
         "</html>"
      );
   }
}

Supponendo che il tuo ambiente sia impostato correttamente, compila HelloForm.java come segue:

$ javac HelloForm.java

Se tutto va bene, la compilazione di cui sopra produrrebbe HelloForm.classfile. Successivamente dovresti copiare questo file di classe in <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes e creare le seguenti voci inweb.xml file situato in <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /

<servlet>
   <servlet-name>HelloForm</servlet-name>
   <servlet-class>HelloForm</servlet-class>
</servlet>

<servlet-mapping>
   <servlet-name>HelloForm</servlet-name>
   <url-pattern>/HelloForm</url-pattern>
</servlet-mapping>

Ora digita http: // localhost: 8080 / HelloForm? First_name = ZARA & last_name = ALI nella casella Posizione: del tuo browser e assicurati di aver già avviato il server Tomcat, prima di eseguire il comando sopra nel browser. Questo genererebbe il seguente risultato:

Using GET Method to Read Form Data

  • First Name: ZARA
  • Last Name: ALI

Esempio di metodo GET utilizzando il modulo

Ecco un semplice esempio che trasmette due valori utilizzando il FORM HTML e il pulsante di invio. Useremo lo stesso servlet HelloForm per gestire questo input.

<html>
   <body>
      <form action = "HelloForm" method = "GET">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
   </body>
</html>

Conserva questo HTML in un file Hello.htm e mettilo nella directory <Tomcat-installationdirectory> / webapps / ROOT. Quando si accede a http: // localhost: 8080 / Hello.htm , ecco l'output effettivo del modulo precedente.

Prova a inserire Nome e Cognome, quindi fai clic sul pulsante Invia per vedere il risultato sul tuo computer locale su cui è in esecuzione Tomcat. Sulla base dell'input fornito, genererà un risultato simile a quello menzionato nell'esempio precedente.

Esempio di metodo POST utilizzando il modulo

Facciamo poche modifiche nel servlet sopra, in modo che possa gestire i metodi GET e POST. Sotto èHelloForm.java programma servlet per gestire l'input fornito dal browser web utilizzando i metodi GET o POST.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

// Extend HttpServlet class
public class HelloForm extends HttpServlet {

   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");

      PrintWriter out = response.getWriter();
      String title = "Using GET Method to Read Form Data";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " +
         "transitional//en\">\n";
         
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<ul>\n" +
                  "  <li><b>First Name</b>: "
                  + request.getParameter("first_name") + "\n" +
                  "  <li><b>Last Name</b>: "
                  + request.getParameter("last_name") + "\n" +
               "</ul>\n" +
            "</body>"
         "</html>"
      );
   }

   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

      doGet(request, response);
   }
}

Ora compila e distribuisci il servlet sopra e testalo usando Hello.htm con il metodo POST come segue:

<html>
   <body>
      <form action = "HelloForm" method = "POST">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
   </body>
</html>

Ecco l'output effettivo del modulo sopra, prova a inserire Nome e Cognome, quindi fai clic sul pulsante Invia per vedere il risultato sul tuo computer locale su cui è in esecuzione Tomcat.

Sulla base dell'input fornito, genererebbe un risultato simile a quello menzionato negli esempi precedenti.

Passaggio dei dati della casella di controllo al programma servlet

Le caselle di controllo vengono utilizzate quando è necessario selezionare più di un'opzione.

Ecco un esempio di codice HTML, CheckBox.htm, per un modulo con due caselle di controllo

<html>
   <body>
      <form action = "CheckBox" method = "POST" target = "_blank">
         <input type = "checkbox" name = "maths" checked = "checked" /> Maths
         <input type = "checkbox" name = "physics"  /> Physics
         <input type = "checkbox" name = "chemistry" checked = "checked" /> 
                                          Chemistry
         <input type = "submit" value = "Select Subject" />
      </form>
   </body>
</html>

Il risultato di questo codice è la seguente forma

Di seguito è riportato il programma servlet CheckBox.java per gestire l'input fornito dal browser Web per il pulsante della casella di controllo.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

// Extend HttpServlet class
public class CheckBox extends HttpServlet {
 
   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");

      PrintWriter out = response.getWriter();
      String title = "Reading Checkbox Data";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";

      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<ul>\n" +
                  "  <li><b>Maths Flag : </b>: "
                  + request.getParameter("maths") + "\n" +
                  "  <li><b>Physics Flag: </b>: "
                  + request.getParameter("physics") + "\n" +
                  "  <li><b>Chemistry Flag: </b>: "
                  + request.getParameter("chemistry") + "\n" +
               "</ul>\n" +
            "</body>"
         "</html>"
      );
   }

   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      doGet(request, response);
   }
}

Per l'esempio precedente, verrà visualizzato il seguente risultato:

Reading Checkbox Data

  • Maths Flag : : on
  • Physics Flag: : null
  • Chemistry Flag: : on

Lettura di tutti i parametri del modulo

Di seguito è riportato l'esempio generico che utilizza getParameterNames()metodo di HttpServletRequest per leggere tutti i parametri del modulo disponibili. Questo metodo restituisce un'enumerazione che contiene i nomi dei parametri in un ordine non specificato

Una volta che abbiamo un'enumerazione, possiamo eseguire il ciclo dell'enumerazione in modo standard, usando il metodo hasMoreElements () per determinare quando fermarsi e usando il metodo nextElement () per ottenere ogni nome di parametro.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

// Extend HttpServlet class
public class ReadParams extends HttpServlet {
 
   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");

      PrintWriter out = response.getWriter();
      String title = "Reading All Form Parameters";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";

      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n" +
         "<body bgcolor = \"#f0f0f0\">\n" +
         "<h1 align = \"center\">" + title + "</h1>\n" +
         "<table width = \"100%\" border = \"1\" align = \"center\">\n" +
         "<tr bgcolor = \"#949494\">\n" +
            "<th>Param Name</th>"
            "<th>Param Value(s)</th>\n"+
         "</tr>\n"
      );

      Enumeration paramNames = request.getParameterNames();

      while(paramNames.hasMoreElements()) {
         String paramName = (String)paramNames.nextElement();
         out.print("<tr><td>" + paramName + "</td>\n<td>");
         String[] paramValues = request.getParameterValues(paramName);

         // Read single valued data
         if (paramValues.length == 1) {
            String paramValue = paramValues[0];
            if (paramValue.length() == 0)
               out.println("<i>No Value</i>");
               else
               out.println(paramValue);
         } else {
            // Read multiple valued data
            out.println("<ul>");

            for(int i = 0; i < paramValues.length; i++) {
               out.println("<li>" + paramValues[i]);
            }
            out.println("</ul>");
         }
      }
      out.println("</tr>\n</table>\n</body></html>");
   }
   
   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      doGet(request, response);
   }
}

Ora, prova il servlet sopra con il seguente modulo:

<html>
   <body>
      <form action = "ReadParams" method = "POST" target = "_blank">
         <input type = "checkbox" name = "maths" checked = "checked" /> Maths
         <input type = "checkbox" name = "physics"  /> Physics
         <input type = "checkbox" name = "chemistry" checked = "checked" /> Chem
         <input type = "submit" value = "Select Subject" />
      </form>
   </body>
</html>

Ora chiamare servlet utilizzando il modulo sopra genererebbe il seguente risultato:

Reading All Form Parameters

Param Name Param Value(s)
maths on
chemistry on

Puoi provare il servlet sopra per leggere i dati di qualsiasi altro modulo con altri oggetti come casella di testo, pulsante di opzione o casella a discesa ecc.

Quando un browser richiede una pagina web, invia molte informazioni al server web che non possono essere lette direttamente perché queste informazioni viaggiano come parte dell'intestazione della richiesta HTTP. Puoi controllare il protocollo HTTP per ulteriori informazioni su questo.

Di seguito sono riportate le importanti informazioni di intestazione che provengono dal lato browser e che useresti molto frequentemente nella programmazione web:

Sr.No. Intestazione e descrizione
1

Accept

Questa intestazione specifica i tipi MIME che il browser o altri client possono gestire. Valori diimage/png o image/jpeg sono le due possibilità più comuni.

2

Accept-Charset

Questa intestazione specifica i set di caratteri che il browser può utilizzare per visualizzare le informazioni. Ad esempio ISO-8859-1.

3

Accept-Encoding

Questa intestazione specifica i tipi di codifiche che il browser sa come gestire. Valori digzip o compress sono le due possibilità più comuni.

4

Accept-Language

Questa intestazione specifica le lingue preferite del client nel caso in cui il servlet possa produrre risultati in più di una lingua. Ad esempio en, en-us, ru, ecc

5

Authorization

Questa intestazione viene utilizzata dai client per identificarsi quando accedono a pagine Web protette da password.

6

Connection

Questa intestazione indica se il client può gestire connessioni HTTP persistenti. Le connessioni persistenti consentono al client o ad un altro browser di recuperare più file con una singola richiesta. Un valore diKeep-Alive significa che devono essere utilizzate connessioni persistenti.

7

Content-Length

Questa intestazione è applicabile solo alle richieste POST e fornisce la dimensione dei dati POST in byte.

8

Cookie

Questa intestazione restituisce i cookie ai server che li hanno precedentemente inviati al browser.

9

Host

Questa intestazione specifica l'host e la porta come indicato nell'URL originale.

10

If-Modified-Since

Questa intestazione indica che il client desidera la pagina solo se è stata modificata dopo la data specificata. Il server invia un codice, 304 che significaNot Modified intestazione se non sono disponibili risultati più recenti.

11

If-Unmodified-Since

Questa intestazione è l'opposto di If-Modified-Since; specifica che l'operazione deve riuscire solo se il documento è più vecchio della data specificata.

12

Referer

Questa intestazione indica l'URL della pagina Web di riferimento. Ad esempio, se ci si trova nella pagina Web 1 e si fa clic su un collegamento alla pagina Web 2, l'URL della pagina Web 1 viene incluso nell'intestazione Referrer quando il browser richiede la pagina Web 2.

13

User-Agent

Questa intestazione identifica il browser o un altro client che effettua la richiesta e può essere utilizzata per restituire contenuto diverso a diversi tipi di browser.

Metodi per leggere l'intestazione HTTP

Esistono i seguenti metodi che possono essere utilizzati per leggere l'intestazione HTTP nel programma servlet. Questi metodi sono disponibili con l' oggetto HttpServletRequest

Sr.No. Metodo e descrizione
1

Cookie[] getCookies()

Restituisce un array contenente tutti gli oggetti Cookie che il client ha inviato con questa richiesta.

2

Enumeration getAttributeNames()

Restituisce un'enumerazione contenente i nomi degli attributi disponibili per questa richiesta.

3

Enumeration getHeaderNames()

Restituisce un'enumerazione di tutti i nomi di intestazione contenuti in questa richiesta.

4

Enumeration getParameterNames()

Restituisce un'enumerazione di oggetti String contenenti i nomi dei parametri contenuti in questa richiesta

5

HttpSession getSession()

Restituisce la sessione corrente associata a questa richiesta o, se la richiesta non ha una sessione, ne crea una.

6

HttpSession getSession(boolean create)

Restituisce la HttpSession corrente associata a questa richiesta o, se non esiste una sessione corrente e il valore di create è true, restituisce una nuova sessione.

7

Locale getLocale()

Restituisce le impostazioni internazionali preferite in cui il client accetterà il contenuto, in base all'intestazione Accept-Language.

8

Object getAttribute(String name)

Restituisce il valore dell'attributo denominato come oggetto o null se non esiste alcun attributo del nome specificato.

9

ServletInputStream getInputStream()

Recupera il corpo della richiesta come dati binari utilizzando un ServletInputStream.

10

String getAuthType()

Restituisce il nome dello schema di autenticazione utilizzato per proteggere il servlet, ad esempio "BASIC" o "SSL" o null se JSP non era protetto.

11

String getCharacterEncoding()

Restituisce il nome della codifica dei caratteri utilizzata nel corpo di questa richiesta.

12

String getContentType()

Restituisce il tipo MIME del corpo della richiesta o null se il tipo non è noto.

13

String getContextPath()

Restituisce la parte dell'URI della richiesta che indica il contesto della richiesta.

14

String getHeader(String name)

Restituisce il valore dell'intestazione della richiesta specificata come String.

15

String getMethod()

Restituisce il nome del metodo HTTP con cui è stata effettuata questa richiesta, ad esempio, GET, POST o PUT.

16

String getParameter(String name)

Restituisce il valore di un parametro di richiesta come String o null se il parametro non esiste.

17

String getPathInfo()

Restituisce eventuali informazioni sul percorso aggiuntive associate all'URL inviato dal client quando ha effettuato questa richiesta

18

String getProtocol()

Restituisce il nome e la versione del protocollo richiesta.

19

String getQueryString()

Restituisce la stringa di query contenuta nell'URL della richiesta dopo il percorso.

20

String getRemoteAddr()

Restituisce l'indirizzo IP (Internet Protocol) del client che ha inviato la richiesta.

21

String getRemoteHost()

Restituisce il nome completo del client che ha inviato la richiesta.

22

String getRemoteUser()

Restituisce il login dell'utente che effettua questa richiesta, se l'utente è stato autenticato, o null se l'utente non è stato autenticato.

23

String getRequestURI()

Restituisce la parte dell'URL di questa richiesta dal nome del protocollo fino alla stringa di query nella prima riga della richiesta HTTP.

24

String getRequestedSessionId()

Restituisce l'ID di sessione specificato dal client.

25

String getServletPath()

Restituisce la parte dell'URL di questa richiesta che chiama il JSP.

26

String[] getParameterValues(String name)

Restituisce un array di oggetti String contenente tutti i valori del parametro di richiesta specificato o null se il parametro non esiste.

27

boolean isSecure()

Restituisce un valore booleano che indica se questa richiesta è stata effettuata utilizzando un canale protetto, come HTTPS.

28

int getContentLength()

Restituisce la lunghezza, in byte, del corpo della richiesta e resa disponibile dal flusso di input, oppure -1 se la lunghezza non è nota.

29

int getIntHeader(String name)

Restituisce il valore dell'intestazione della richiesta specificata come int.

30

int getServerPort()

Restituisce il numero di porta su cui è stata ricevuta questa richiesta.

Esempio di richiesta di intestazione HTTP

Di seguito è riportato l'esempio che utilizza getHeaderNames()metodo di HttpServletRequest per leggere le informazioni sull'intestazione HTTP. Questo metodo restituisce un'enumerazione che contiene le informazioni di intestazione associate alla richiesta HTTP corrente.

Una volta che abbiamo un'enumerazione, possiamo eseguire il ciclo dell'enumerazione nel modo standard, usando il metodo hasMoreElements () per determinare quando fermarsi e usando il metodo nextElement () per ottenere ogni nome di parametro

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
 
// Extend HttpServlet class
public class DisplayHeader extends HttpServlet {
 
   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");
 
      PrintWriter out = response.getWriter();
      String title = "HTTP Header Request Example";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";

      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n"+
         "<body bgcolor = \"#f0f0f0\">\n" +
         "<h1 align = \"center\">" + title + "</h1>\n" +
         "<table width = \"100%\" border = \"1\" align = \"center\">\n" +
         "<tr bgcolor = \"#949494\">\n" +
         "<th>Header Name</th><th>Header Value(s)</th>\n"+
         "</tr>\n"
      );
 
      Enumeration headerNames = request.getHeaderNames();
    
      while(headerNames.hasMoreElements()) {
         String paramName = (String)headerNames.nextElement();
         out.print("<tr><td>" + paramName + "</td>\n");
         String paramValue = request.getHeader(paramName);
         out.println("<td> " + paramValue + "</td></tr>\n");
      }
      out.println("</table>\n</body></html>");
   }
   
   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

      doGet(request, response);
   }
}

Ora chiamare il servlet sopra genererebbe il seguente risultato:

HTTP Header Request Example

Header Name Header Value(s)
accept */*
accept-language en-us
user-agent Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; InfoPath.2; MS-RTC LM 8)
accept-encoding gzip, deflate
host localhost:8080
connection Keep-Alive
cache-control no-cache

Come discusso nel capitolo precedente, quando un server Web risponde a una richiesta HTTP, la risposta consiste in genere in una riga di stato, alcune intestazioni di risposta, una riga vuota e il documento. Una risposta tipica è simile a questa:

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>
<html>
   <head>...</head>
   <body>
      ...
   </body>
</html>

La riga di stato è composta dalla versione HTTP (HTTP / 1.1 nell'esempio), un codice di stato (200 nell'esempio) e un messaggio molto breve corrispondente al codice di stato (OK nell'esempio).

Di seguito è riportato un riepilogo delle intestazioni di risposta HTTP 1.1 più utili che risalgono al browser dal lato server web e che useresti molto frequentemente nella programmazione web -

Sr.No. Intestazione e descrizione
1

Allow

Questa intestazione specifica i metodi di richiesta (GET, POST, ecc.) Supportati dal server.

2

Cache-Control

Questa intestazione specifica le circostanze in cui il documento di risposta può essere memorizzato nella cache in modo sicuro. Può avere valoripublic, private o no-cache ecc. Pubblico significa che il documento è memorizzabile nella cache, Privato significa che il documento è per un singolo utente e può essere memorizzato solo in cache private (non condivise) e nocache significa che il documento non deve mai essere memorizzato nella cache.

3

Connection

Questa intestazione indica al browser se utilizzare o meno il persistente nelle connessioni HTTP. Un valore diclose indica al browser di non utilizzare connessioni HTTP persistenti e keepalive significa usare connessioni persistenti.

4

Content-Disposition

Questa intestazione consente di richiedere che il browser chieda all'utente di salvare la risposta su disco in un file con il nome specificato.

5

Content-Encoding

Questa intestazione specifica il modo in cui la pagina è stata codificata durante la trasmissione.

6

Content-Language

Questa intestazione indica la lingua in cui è scritto il documento. Ad esempio en, en-us, ru, ecc

7

Content-Length

Questa intestazione indica il numero di byte nella risposta. Queste informazioni sono necessarie solo se il browser utilizza una connessione HTTP persistente (keep-alive).

8

Content-Type

Questa intestazione fornisce il tipo MIME (Multipurpose Internet Mail Extension) del documento di risposta.

9

Expires

Questa intestazione specifica l'ora in cui il contenuto deve essere considerato non aggiornato e quindi non deve più essere memorizzato nella cache.

10

Last-Modified

Questa intestazione indica quando il documento è stato modificato l'ultima volta. Il client può quindi memorizzare il documento nella cache e fornire una data tramite un fileIf-Modified-Since richiesta di intestazione nelle richieste successive.

11

Location

Questa intestazione dovrebbe essere inclusa in tutte le risposte che hanno un codice di stato nei 300. Questo notifica al browser l'indirizzo del documento. Il browser si riconnette automaticamente a questa posizione e recupera il nuovo documento.

12

Refresh

Questa intestazione specifica quanto presto il browser dovrebbe richiedere una pagina aggiornata. È possibile specificare il tempo in numero di secondi dopo il quale una pagina verrà aggiornata.

13

Retry-After

Questa intestazione può essere utilizzata insieme a una risposta 503 (Servizio non disponibile) per indicare al client quanto tempo può ripetere la sua richiesta.

14

Set-Cookie

Questa intestazione specifica un cookie associato alla pagina.

Metodi per impostare l'intestazione della risposta HTTP

Esistono i seguenti metodi che possono essere utilizzati per impostare l'intestazione della risposta HTTP nel programma servlet. Questi metodi sono disponibili con l' oggetto HttpServletResponse .

Sr.No. Metodo e descrizione
1

String encodeRedirectURL(String url)

Codifica l'URL specificato per l'utilizzo nel metodo sendRedirect o, se la codifica non è necessaria, restituisce l'URL invariato.

2

String encodeURL(String url)

Codifica l'URL specificato includendovi l'ID di sessione oppure, se la codifica non è necessaria, restituisce l'URL invariato.

3

boolean containsHeader(String name)

Restituisce un valore booleano che indica se l'intestazione della risposta denominata è già stata impostata.

4

boolean isCommitted()

Restituisce un valore booleano che indica se la risposta è stata confermata.

5

void addCookie(Cookie cookie)

Aggiunge il cookie specificato alla risposta.

6

void addDateHeader(String name, long date)

Aggiunge un'intestazione di risposta con il nome e il valore della data forniti.

7

void addHeader(String name, String value)

Aggiunge un'intestazione di risposta con il nome e il valore forniti.

8

void addIntHeader(String name, int value)

Aggiunge un'intestazione di risposta con il nome specificato e il valore intero.

9

void flushBuffer()

Forza la scrittura sul client di qualsiasi contenuto nel buffer.

10

void reset()

Cancella tutti i dati presenti nel buffer, nonché il codice di stato e le intestazioni.

11

void resetBuffer()

Cancella il contenuto del buffer sottostante nella risposta senza cancellare le intestazioni o il codice di stato.

12

void sendError(int sc)

Invia una risposta di errore al client utilizzando il codice di stato specificato e cancellando il buffer.

13

void sendError(int sc, String msg)

Invia una risposta di errore al client utilizzando lo stato specificato.

14

void sendRedirect(String location)

Invia una risposta di reindirizzamento temporaneo al client utilizzando l'URL del percorso di reindirizzamento specificato.

15

void setBufferSize(int size)

Imposta la dimensione del buffer preferita per il corpo della risposta.

16

void setCharacterEncoding(String charset)

Imposta la codifica dei caratteri (set di caratteri MIME) della risposta inviata al client, ad esempio, su UTF-8.

17

void setContentLength(int len)

Imposta la lunghezza del corpo del contenuto nella risposta Nei servlet HTTP, questo metodo imposta l'intestazione HTTP Content-Length.

18

void setContentType(String type)

Imposta il tipo di contenuto della risposta inviata al client, se la risposta non è stata ancora confermata.

19

void setDateHeader(String name, long date)

Imposta un'intestazione di risposta con il nome e il valore della data specificati.

20

void setHeader(String name, String value)

Imposta un'intestazione di risposta con il nome e il valore forniti.

21

void setIntHeader(String name, int value)

Imposta un'intestazione di risposta con il nome specificato e il valore intero

22

void setLocale(Locale loc)

Imposta la locale della risposta, se la risposta non è stata ancora confermata.

23

void setStatus(int sc)

Imposta il codice di stato per questa risposta

Esempio di risposta dell'intestazione HTTP

Hai già visto il metodo setContentType () funzionare negli esempi precedenti e anche il seguente esempio userebbe lo stesso metodo, inoltre useremmo setIntHeader() metodo da impostare Refresh intestazione.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
 
// Extend HttpServlet class
public class Refresh extends HttpServlet {
 
   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
   
      // Set refresh, autoload time as 5 seconds
      response.setIntHeader("Refresh", 5);
 
      // Set response content type
      response.setContentType("text/html");
 
      // Get current time
      Calendar calendar = new GregorianCalendar();
      String am_pm;
      int hour = calendar.get(Calendar.HOUR);
      int minute = calendar.get(Calendar.MINUTE);
      int second = calendar.get(Calendar.SECOND);
         
      if(calendar.get(Calendar.AM_PM) == 0)
         am_pm = "AM";
      else
         am_pm = "PM";
 
      String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
    
      PrintWriter out = response.getWriter();
      String title = "Auto Refresh Header Setting";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";

      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n"+
         "<body bgcolor = \"#f0f0f0\">\n" +
         "<h1 align = \"center\">" + title + "</h1>\n" +
         "<p>Current Time is: " + CT + "</p>\n"
      );
   }
   
   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      doGet(request, response);
   }
}

Ora chiamando il servlet sopra verrà visualizzato l'ora del sistema corrente ogni 5 secondi come segue. Basta eseguire il servlet e attendere di vedere il risultato -

Auto Refresh Header Setting

Current Time is: 9:44:50 PM

Il formato della richiesta HTTP e dei messaggi di risposta HTTP sono simili e avranno la seguente struttura:

  • Una riga di stato iniziale + CRLF (Carriage Return + Line Feed ie New Line)

  • Zero o più righe di intestazione + CRLF

  • Una riga vuota, cioè un CRLF

  • Un corpo del messaggio opzionale come file, dati di query o output di query.

Ad esempio, un'intestazione di risposta del server ha il seguente aspetto:

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>
<html>
   <head>...</head>
   <body>
      ...
   </body>
</html>

La riga di stato è composta dalla versione HTTP (HTTP / 1.1 nell'esempio), un codice di stato (200 nell'esempio) e un messaggio molto breve corrispondente al codice di stato (OK nell'esempio).

Di seguito è riportato un elenco di codici di stato HTTP e messaggi associati che potrebbero essere restituiti dal server Web:

Codice Messaggio Descrizione
100 Continua Solo una parte della richiesta è stata ricevuta dal server, ma fino a quando non è stata rifiutata, il client dovrebbe continuare con la richiesta
101 Cambio di protocollo Il server cambia protocollo.
200 ok La richiesta è OK
201 Creato La richiesta è completa e viene creata una nuova risorsa
202 Accettato La richiesta viene accettata per l'elaborazione, ma l'elaborazione non è completa.
203 Informazioni non autorevoli  
204 Nessun contenuto  
205 Reimposta contenuto  
206 Contenuto parziale  
300 Scelte multiple Un elenco di collegamenti. L'utente può selezionare un collegamento e andare a quella posizione. Massimo cinque indirizzi
301 trasferito La pagina richiesta è stata spostata su un nuovo URL
302 Trovato La pagina richiesta è stata temporaneamente spostata su un nuovo URL
303 Vedi altro La pagina richiesta può essere trovata sotto un URL diverso
304 Non modificato  
305 Usa un proxy  
306 Inutilizzato Questo codice è stato utilizzato in una versione precedente. Non è più utilizzato, ma il codice è riservato
307 Reindirizzamento temporaneo La pagina richiesta è stata temporaneamente spostata su un nuovo URL.
400 Brutta richiesta Il server non ha compreso la richiesta
401 Non autorizzato La pagina richiesta richiede un nome utente e una password
402 Pagamento richiesto Non puoi ancora usare questo codice
403 Vietato Vietato l'accesso alla pagina richiesta
404 Non trovato Il server non riesce a trovare la pagina richiesta.
405 operazione non permessa Il metodo specificato nella richiesta non è consentito.
406 Non accettabile Il server può generare solo una risposta non accettata dal client.
407 Autenticazione proxy richiesta È necessario autenticarsi con un server proxy prima di poter servire questa richiesta.
408 Richiedi timeout La richiesta ha richiesto più tempo di quanto il server fosse disposto ad attendere.
409 Conflitto La richiesta non può essere completata a causa di un conflitto.
410 Andato La pagina richiesta non è più disponibile.
411 Lunghezza richiesta La "lunghezza del contenuto" non è definita. Il server non accetterà la richiesta senza di essa.
412 Precondizione non riuscita La precondizione data nella richiesta valutata come falsa dal server.
413 Entità richiesta troppo grande Il server non accetterà la richiesta, perché l'entità della richiesta è troppo grande.
414 URL richiesta troppo lungo Il server non accetterà la richiesta, perché l'URL è troppo lungo. Si verifica quando si converte una richiesta "post" in una richiesta "get" con una lunga query di informazioni.
415 Tipo di supporto non supportato Il server non accetterà la richiesta, perché il tipo di supporto non è supportato.
417 Aspettativa fallita  
500 Errore interno del server La richiesta non è stata completata. Il server ha incontrato una condizione imprevista.
501 Non implementato La richiesta non è stata completata. Il server non supportava la funzionalità richiesta.
502 Bad Gateway La richiesta non è stata completata. Il server ha ricevuto una risposta non valida dal server upstream.
503 Servizio non disponibile La richiesta non è stata completata. Il server è temporaneamente in sovraccarico o inattivo.
504 Timeout gateway Il gateway è scaduto.
505 Versione HTTP non supportata Il server non supporta la versione "protocollo http".

Metodi per impostare il codice di stato HTTP

I seguenti metodi possono essere utilizzati per impostare il codice di stato HTTP nel programma servlet. Questi metodi sono disponibili con l' oggetto HttpServletResponse .

Sr.No. Metodo e descrizione
1

public void setStatus ( int statusCode )

Questo metodo imposta un codice di stato arbitrario. Il metodo setStatus accetta un int (il codice di stato) come argomento. Se la tua risposta include un codice di stato speciale e un documento, assicurati di chiamare setStatus prima di restituire effettivamente qualsiasi contenuto con PrintWriter .

2

public void sendRedirect(String url)

Questo metodo genera una risposta 302 insieme a un'intestazione Location che fornisce l'URL del nuovo documento

3

public void sendError(int code, String message)

Questo metodo invia un codice di stato (solitamente 404) insieme a un breve messaggio che viene automaticamente formattato all'interno di un documento HTML e inviato al client.

Esempio di codice di stato HTTP

Di seguito è riportato l'esempio che invierà un codice di errore 407 al browser client e il browser mostrerà "Necessaria autenticazione !!!" Messaggio.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

// Extend HttpServlet class
public class showError extends HttpServlet {
 
   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set error code and reason.
      response.sendError(407, "Need authentication!!!" );
   }
   
   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      doGet(request, response);
   }
}

Ora chiamando il servlet sopra verrà visualizzato il seguente risultato:

HTTP Status 407 - Need authentication!!!

type Status report

messageNeed authentication!!!

descriptionThe client must first authenticate itself with the proxy (Need authentication!!!).

Apache Tomcat/5.5.29

I filtri servlet sono classi Java che possono essere utilizzate nella programmazione servlet per i seguenti scopi:

  • Per intercettare le richieste di un client prima che acceda a una risorsa nel back-end.

  • Per manipolare le risposte dal server prima che vengano rispedite al client.

Esistono vari tipi di filtri suggeriti dalle specifiche:

  • Filtri di autenticazione.
  • Filtri di compressione dati.
  • Filtri di crittografia.
  • Filtri che attivano eventi di accesso alle risorse.
  • Filtri di conversione delle immagini.
  • Filtri di registrazione e controllo.
  • Filtri catena TIPO MIME.
  • Filtri di tokenizzazione.
  • Filtri XSL / T che trasformano il contenuto XML.

I filtri vengono distribuiti nel file descrittore di distribuzione web.xml e quindi eseguire il mapping ai nomi dei servlet o ai pattern URL nel descrittore di distribuzione dell'applicazione.

Quando il contenitore web avvia la tua applicazione web, crea un'istanza di ogni filtro che hai dichiarato nel descrittore di distribuzione. I filtri vengono eseguiti nell'ordine in cui sono dichiarati nel descrittore di distribuzione.

Metodi di filtro servlet

Un filtro è semplicemente una classe Java che implementa l'interfaccia javax.servlet.Filter. L'interfaccia javax.servlet.Filter definisce tre metodi:

Sr.No. Metodo e descrizione
1

public void doFilter (ServletRequest, ServletResponse, FilterChain)

Questo metodo viene chiamato dal contenitore ogni volta che una coppia richiesta / risposta viene passata attraverso la catena a causa di una richiesta del client per una risorsa alla fine della catena.

2

public void init(FilterConfig filterConfig)

Questo metodo viene chiamato dal contenitore Web per indicare a un filtro che viene messo in servizio.

3

public void destroy()

Questo metodo viene chiamato dal contenitore Web per indicare a un filtro che è stato messo fuori servizio.

Filtro servlet - Esempio

Di seguito è riportato l'esempio di filtro servlet che stampa l'indirizzo IP dei client e la data e l'ora correnti. Questo esempio ti darebbe una conoscenza di base del Servlet Filter, ma puoi scrivere applicazioni di filtro più sofisticate usando lo stesso concetto -

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

// Implements Filter class
public class LogFilter implements Filter  {
   public void  init(FilterConfig config) throws ServletException {
      
      // Get init parameter 
      String testParam = config.getInitParameter("test-param"); 

      //Print the init parameter 
      System.out.println("Test Param: " + testParam); 
   }
   
   public void  doFilter(ServletRequest request, ServletResponse response,
      FilterChain chain) throws java.io.IOException, ServletException {

      // Get the IP address of client machine.
      String ipAddress = request.getRemoteAddr();

      // Log the IP address and current timestamp.
      System.out.println("IP "+ ipAddress + ", Time " + new Date().toString());

      // Pass request back down the filter chain
      chain.doFilter(request,response);
   }

   public void destroy( ) {
      /* Called before the Filter instance is removed from service by the web container*/
   }
}

Compilare LogFilter.java nel solito modo e metti il ​​tuo file di classe in <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes

Mappatura filtri servlet in Web.xml

I filtri vengono definiti e quindi mappati su un URL o Servlet, in modo molto simile a come viene definito Servlet e quindi mappato a un pattern URL. Creare la seguente voce per il tag di filtro nel file descrittore di distribuzioneweb.xml

<filter>
   <filter-name>LogFilter</filter-name>
   <filter-class>LogFilter</filter-class>
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>

<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

Il filtro sopra si applicherebbe a tutti i servlet perché abbiamo specificato /*nella nostra configurazione. È possibile specificare un particolare percorso servlet se si desidera applicare il filtro solo a pochi servlet.

Ora prova a chiamare qualsiasi servlet nel solito modo e vedrai il log generato nel log del tuo server web. È possibile utilizzare il logger Log4J per accedere al registro sopra in un file separato.

Utilizzo di più filtri

La tua applicazione web può definire diversi filtri differenti con uno scopo specifico. Considera che definisci due filtri AuthenFilter e LogFilter . Il resto del processo rimarrà come spiegato sopra tranne che è necessario creare una mappatura diversa come indicato di seguito -

<filter>
   <filter-name>LogFilter</filter-name>
   <filter-class>LogFilter</filter-class>
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>

<filter>
   <filter-name>AuthenFilter</filter-name>
   <filter-class>AuthenFilter</filter-class>
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>

<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

<filter-mapping>
   <filter-name>AuthenFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

Ordine applicazione filtri

L'ordine degli elementi di mappatura del filtro in web.xml determina l'ordine in cui il contenitore web applica il filtro al servlet. Per invertire l'ordine del filtro, è sufficiente invertire gli elementi di mappatura del filtro nel file web.xml.

Ad esempio, l'esempio precedente applica prima LogFilter e quindi applica AuthenFilter a qualsiasi servlet, ma l'esempio seguente inverte l'ordine:

<filter-mapping>
   <filter-name>AuthenFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

Quando un servlet genera un'eccezione, il contenitore web cerca le configurazioni in web.xml che utilizzano l'elemento di tipo eccezione per una corrispondenza con il tipo di eccezione generato.

Dovresti usare il file error-page elemento in web.xml per specificare l'invocazione di servlet in risposta a determinati exceptions o HTTP status codes.

Configurazione web.xml

Considera, hai un servlet ErrorHandler che verrebbe chiamato ogni volta che c'è un'eccezione o un errore definito. Di seguito sarebbe la voce creata in web.xml.

<!-- servlet definition -->
<servlet>
   <servlet-name>ErrorHandler</servlet-name>
   <servlet-class>ErrorHandler</servlet-class>
</servlet>

<!-- servlet mappings -->
<servlet-mapping>
   <servlet-name>ErrorHandler</servlet-name>
   <url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>

<!-- error-code related error pages -->
<error-page>
   <error-code>404</error-code>
   <location>/ErrorHandler</location>
</error-page>

<error-page>
   <error-code>403</error-code>
   <location>/ErrorHandler</location>
</error-page>

<!-- exception-type related error pages -->
<error-page>
   <exception-type>
      javax.servlet.ServletException
   </exception-type >
   <location>/ErrorHandler</location>
</error-page>

<error-page>
   <exception-type>java.io.IOException</exception-type >
   <location>/ErrorHandler</location>
</error-page>

Se si desidera avere un gestore degli errori generico per tutte le eccezioni, è necessario definire la seguente pagina di errore invece di definire elementi di pagina di errore separati per ogni eccezione -

<error-page>
   <exception-type>java.lang.Throwable</exception-type >
   <location>/ErrorHandler</location>
</error-page>

Di seguito sono riportati i punti da notare su web.xml sopra per la gestione delle eccezioni:

  • Il servlet ErrorHandler è definito come qualsiasi altro servlet e configurato in web.xml.

  • Se si verifica un errore con il codice di stato 404 (non trovato) o 403 (vietato), verrà chiamato il servlet ErrorHandler.

  • Se l'applicazione Web genera ServletException o IOException, il contenitore Web richiama il servlet / ErrorHandler.

  • È possibile definire diversi gestori di errori per gestire diversi tipi di errori o eccezioni. L'esempio sopra è molto generico e spero che serva allo scopo di spiegarti il ​​concetto di base.

Attributi della richiesta: errori / eccezioni

Di seguito è riportato l'elenco degli attributi della richiesta a cui un servlet di gestione degli errori può accedere per analizzare la natura dell'errore / eccezione.

Sr.No. Attributo e descrizione
1

javax.servlet.error.status_code

Questo attributo fornisce un codice di stato che può essere memorizzato e analizzato dopo la memorizzazione in un tipo di dati java.lang.Integer.

2

javax.servlet.error.exception_type

Questo attributo fornisce informazioni sul tipo di eccezione che possono essere memorizzate e analizzate dopo la memorizzazione in un tipo di dati java.lang.Class.

3

javax.servlet.error.message

Questo attributo fornisce informazioni sul messaggio di errore esatto che può essere memorizzato e analizzato dopo la memorizzazione in un tipo di dati java.lang.String.

4

javax.servlet.error.request_uri

Questo attributo fornisce informazioni sull'URL che chiama il servlet e può essere memorizzato e analizzato dopo la memorizzazione in un tipo di dati java.lang.String.

5

javax.servlet.error.exception

Questo attributo fornisce informazioni sull'eccezione sollevata, che possono essere archiviate e analizzate.

6

javax.servlet.error.servlet_name

Questo attributo fornisce il nome del servlet che può essere memorizzato e analizzato dopo la memorizzazione in un tipo di dati java.lang.String.

Esempio di servlet del gestore degli errori

Questo esempio fornisce una conoscenza di base della gestione delle eccezioni in Servlet, ma è possibile scrivere applicazioni di filtro più sofisticate utilizzando lo stesso concetto:

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

// Extend HttpServlet class
public class ErrorHandler extends HttpServlet {
 
   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
         
      // Analyze the servlet exception       
      Throwable throwable = (Throwable)
      request.getAttribute("javax.servlet.error.exception");
      Integer statusCode = (Integer)
      request.getAttribute("javax.servlet.error.status_code");
      String servletName = (String)
      request.getAttribute("javax.servlet.error.servlet_name");
         
      if (servletName == null) {
         servletName = "Unknown";
      }
      String requestUri = (String)
      request.getAttribute("javax.servlet.error.request_uri");
      
      if (requestUri == null) {
         requestUri = "Unknown";
      }

      // Set response content type
      response.setContentType("text/html");

      PrintWriter out = response.getWriter();
      String title = "Error/Exception Information";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " +
         "transitional//en\">\n";
         
      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n" +
         "<body bgcolor = \"#f0f0f0\">\n");

      if (throwable == null && statusCode == null) {
         out.println("<h2>Error information is missing</h2>");
         out.println("Please return to the <a href=\"" + 
            response.encodeURL("http://localhost:8080/") + 
            "\">Home Page</a>.");
      } else if (statusCode != null) {
         out.println("The status code : " + statusCode);
      } else {
         out.println("<h2>Error information</h2>");
         out.println("Servlet Name : " + servletName + "</br></br>");
         out.println("Exception Type : " + throwable.getClass( ).getName( ) + "</br></br>");
         out.println("The request URI: " + requestUri + "<br><br>");
         out.println("The exception message: " + throwable.getMessage( ));
      }
      out.println("</body>");
      out.println("</html>");
   }
   
   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      doGet(request, response);
   }
}

Compilare ErrorHandler.java nel solito modo e metti il ​​tuo file di classe in / webapps / ROOT / WEB-INF / classes.

Aggiungiamo la seguente configurazione in web.xml per gestire le eccezioni:

<servlet>
   <servlet-name>ErrorHandler</servlet-name>
   <servlet-class>ErrorHandler</servlet-class>
</servlet>

<!-- servlet mappings -->
<servlet-mapping>
   <servlet-name>ErrorHandler</servlet-name>
   <url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>

<error-page>
   <error-code>404</error-code>
   <location>/ErrorHandler</location>
</error-page>

<error-page>
   <exception-type>java.lang.Throwable</exception-type >
   <location>/ErrorHandler</location>
</error-page>

Ora prova a utilizzare un servlet che solleva un'eccezione o digita un URL sbagliato, questo attiverà la chiamata di Web Container ErrorHandlerservlet e visualizzare un messaggio appropriato come programmato. Ad esempio, se digiti un URL sbagliato, verrà visualizzato il seguente risultato:

The status code : 404

Il codice sopra potrebbe non funzionare con alcuni browser web. Quindi prova con Mozilla e Safari e dovrebbe funzionare.

I cookie sono file di testo memorizzati sul computer client e vengono conservati per vari scopi di tracciamento delle informazioni. I Java Servlet supportano in modo trasparente i cookie HTTP.

Ci sono tre passaggi coinvolti nell'identificazione degli utenti di ritorno:

  • Lo script del server invia una serie di cookie al browser. Ad esempio nome, età o numero di identificazione ecc.

  • Il browser memorizza queste informazioni sulla macchina locale per un utilizzo futuro.

  • La volta successiva che il browser invia una richiesta al server Web, invia tali informazioni sui cookie al server e il server utilizza tali informazioni per identificare l'utente.

Questo capitolo ti insegnerà come impostare o resettare i cookie, come accedervi e come eliminarli.

L'anatomia di un biscotto

I cookie vengono solitamente impostati in un'intestazione HTTP (sebbene JavaScript possa anche impostare un cookie direttamente su un browser). Un servlet che imposta un cookie potrebbe inviare intestazioni che assomigliano a questo:

HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name = xyz; expires = Friday, 04-Feb-07 22:03:38 GMT; 
   path = /; domain = tutorialspoint.com
Connection: close
Content-Type: text/html

Come puoi vedere, l'intestazione Set-Cookie contiene una coppia di valori nome, una data GMT, un percorso e un dominio. Il nome e il valore saranno codificati in URL. Il campo expires è un'istruzione al browser per "dimenticare" il cookie dopo l'ora e la data specificate.

Se il browser è configurato per memorizzare i cookie, conserverà queste informazioni fino alla data di scadenza. Se l'utente punta il browser su una pagina che corrisponde al percorso e al dominio del cookie, rinvierà il cookie al server. Le intestazioni del browser potrebbero assomigliare a questo:

GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126
Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name = xyz

Un servlet avrà quindi accesso al cookie tramite il metodo di richiesta request.getCookies () che restituisce un array di oggetti Cookie .

Metodi dei cookie servlet

Di seguito è riportato l'elenco dei metodi utili che è possibile utilizzare durante la manipolazione dei cookie in servlet.

Sr.No. Metodo e descrizione
1

public void setDomain(String pattern)

Questo metodo imposta il dominio a cui si applica il cookie, ad esempio tutorialspoint.com.

2

public String getDomain()

Questo metodo ottiene il dominio a cui si applica il cookie, ad esempio tutorialspoint.com.

3

public void setMaxAge(int expiry)

Questo metodo imposta quanto tempo (in secondi) deve trascorrere prima che il cookie scada. Se non lo imposti, il cookie durerà solo per la sessione corrente.

4

public int getMaxAge()

Questo metodo restituisce la durata massima del cookie, specificata in secondi. Per impostazione predefinita, -1 indica che il cookie persisterà fino alla chiusura del browser.

5

public String getName()

Questo metodo restituisce il nome del cookie. Il nome non può essere modificato dopo la creazione.

6

public void setValue(String newValue)

Questo metodo imposta il valore associato al cookie

7

public String getValue()

Questo metodo ottiene il valore associato al cookie.

8

public void setPath(String uri)

Questo metodo imposta il percorso a cui si applica questo cookie. Se non specifichi un percorso, il cookie viene restituito per tutti gli URL nella stessa directory della pagina corrente e per tutte le sottodirectory.

9

public String getPath()

Questo metodo ottiene il percorso a cui si applica questo cookie.

10

public void setSecure(boolean flag)

Questo metodo imposta il valore booleano che indica se il cookie deve essere inviato solo tramite connessioni crittografate (ovvero SSL).

11

public void setComment(String purpose)

Questo metodo specifica un commento che descrive lo scopo di un cookie. Il commento è utile se il browser presenta il cookie all'utente.

12

public String getComment()

Questo metodo restituisce il commento che descrive lo scopo di questo cookie o null se il cookie non ha commenti.

Impostazione dei cookie con Servlet

L'impostazione dei cookie con servlet prevede tre passaggi:

(1) Creating a Cookie object - Chiami il costruttore di cookie con un nome di cookie e un valore di cookie, entrambi stringhe.

Cookie cookie = new Cookie("key","value");

Tieni presente che né il nome né il valore devono contenere spazi bianchi o uno dei seguenti caratteri:

[ ] ( ) = , " / ? @ : ;

(2) Setting the maximum age- Utilizza setMaxAge per specificare per quanto tempo (in secondi) il cookie deve essere valido. Di seguito viene impostato un cookie per 24 ore.

cookie.setMaxAge(60 * 60 * 24);

(3) Sending the Cookie into the HTTP response headers - Utilizza response.addCookie per aggiungere cookie nell'intestazione della risposta HTTP come segue:

response.addCookie(cookie);

Esempio

Modifichiamo il nostro Form Example per impostare i cookie per nome e cognome.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
// Extend HttpServlet class
public class HelloForm extends HttpServlet {

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Create cookies for first and last names.      
      Cookie firstName = new Cookie("first_name", request.getParameter("first_name"));
      Cookie lastName = new Cookie("last_name", request.getParameter("last_name"));

      // Set expiry date after 24 Hrs for both the cookies.
      firstName.setMaxAge(60*60*24);
      lastName.setMaxAge(60*60*24);

      // Add both the cookies in the response header.
      response.addCookie( firstName );
      response.addCookie( lastName );

      // Set response content type
      response.setContentType("text/html");
 
      PrintWriter out = response.getWriter();
      String title = "Setting Cookies Example";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head>
               <title>" + title + "</title>
            </head>\n" +
            
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<ul>\n" +
                  "  <li><b>First Name</b>: "
                  + request.getParameter("first_name") + "\n" +
                  "  <li><b>Last Name</b>: "
                  + request.getParameter("last_name") + "\n" +
               "</ul>\n" +
            "</body>
         </html>"
      );
   }
}

Compila il servlet sopra HelloForm e creare la voce appropriata nel file web.xml e infine provare a seguire la pagina HTML per chiamare servlet.

<html>
   <body>
      <form action = "HelloForm" method = "GET">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
   </body>
</html>

Mantieni il contenuto HTML sopra in un file Hello.htm e mettilo nella directory <Tomcat-installationdirectory> / webapps / ROOT. Quando si accede a http: // localhost: 8080 / Hello.htm , ecco l'output effettivo del modulo precedente.

Prova a inserire Nome e Cognome, quindi fai clic sul pulsante Invia. Questo mostrerebbe il nome e il cognome sullo schermo e allo stesso tempo imposterebbe due cookie firstName e lastName che sarebbero passati di nuovo al server la prossima volta che si premerà il pulsante Invia.

La sezione successiva spiegherebbe come accedere a questi cookie nella tua applicazione web.

Lettura di biscotti con servlet

Per leggere i cookie, è necessario creare un array di oggetti javax.servlet.http.Cookie chiamando ilgetCookies()metodo di HttpServletRequest . Quindi scorrere l'array e utilizzare i metodi getName () e getValue () per accedere a ciascun cookie e al valore associato.

Esempio

Leggiamo i cookie che abbiamo impostato nell'esempio precedente -

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
// Extend HttpServlet class
public class ReadCookies extends HttpServlet {
 
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      Cookie cookie = null;
      Cookie[] cookies = null;

      // Get an array of Cookies associated with this domain
      cookies = request.getCookies();

      // Set response content type
      response.setContentType("text/html");

      PrintWriter out = response.getWriter();
      String title = "Reading Cookies Example";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " +
         "transitional//en\">\n";
         
      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n" +
         "<body bgcolor = \"#f0f0f0\">\n" );

      if( cookies != null ) {
         out.println("<h2> Found Cookies Name and Value</h2>");

         for (int i = 0; i < cookies.length; i++) {
            cookie = cookies[i];
            out.print("Name : " + cookie.getName( ) + ",  ");
            out.print("Value: " + cookie.getValue( ) + " <br/>");
         }
      } else {
         out.println("<h2>No cookies founds</h2>");
      }
      out.println("</body>");
      out.println("</html>");
   }
}

Compila il servlet sopra ReadCookiese creare la voce appropriata nel file web.xml. Se avessi impostato il cookie first_name come "John" e il cookie last_name come "Player", l'esecuzione di http: // localhost: 8080 / ReadCookies visualizzerebbe il seguente risultato:

Found Cookies Name and Value

Name : first_name, Value: John
Name : last_name, Value: Player

Elimina i cookie con Servlet

Eliminare i cookie è molto semplice. Se desideri eliminare un cookie, devi semplicemente seguire i tre passaggi seguenti:

  • Leggere un cookie già esistente e salvarlo nell'oggetto Cookie.

  • Imposta l'età dei cookie su zero utilizzando setMaxAge() metodo per eliminare un cookie esistente

  • Aggiungi di nuovo questo cookie nell'intestazione della risposta.

Esempio

Il seguente esempio eliminerebbe il cookie esistente denominato "first_name" e quando si eseguirà il servlet ReadCookies la prossima volta, restituirà un valore nullo per first_name.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
// Extend HttpServlet class
public class DeleteCookies extends HttpServlet {
 
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      Cookie cookie = null;
      Cookie[] cookies = null;
         
      // Get an array of Cookies associated with this domain
      cookies = request.getCookies();

      // Set response content type
      response.setContentType("text/html");
 
      PrintWriter out = response.getWriter();
      String title = "Delete Cookies Example";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
         
      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n" +
         "<body bgcolor = \"#f0f0f0\">\n" );
         
      if( cookies != null ) {
         out.println("<h2> Cookies Name and Value</h2>");

         for (int i = 0; i < cookies.length; i++) {
            cookie = cookies[i];

            if((cookie.getName( )).compareTo("first_name") == 0 ) {
               cookie.setMaxAge(0);
               response.addCookie(cookie);
               out.print("Deleted cookie : " + cookie.getName( ) + "<br/>");
            }
            out.print("Name : " + cookie.getName( ) + ",  ");
            out.print("Value: " + cookie.getValue( )+" <br/>");
         }
      } else {
         out.println("<h2>No cookies founds</h2>");
      }
      out.println("</body>");
      out.println("</html>");
   }
}

Compila il servlet sopra DeleteCookiese creare la voce appropriata nel file web.xml. Ora l'esecuzione di http: // localhost: 8080 / DeleteCookies visualizzerà il seguente risultato:

Cookies Name and Value

Deleted cookie : first_name

Name : first_name, Value: John

Name : last_name, Value: Player

Ora prova a eseguire http: // localhost: 8080 / ReadCookies e visualizzerà solo un cookie come segue:

Found Cookies Name and Value

Name : last_name, Value: Player

È possibile eliminare manualmente i cookie in Internet Explorer. Inizia dal menu Strumenti e seleziona Opzioni Internet. Per eliminare tutti i cookie, premere Elimina cookie.

HTTP è un protocollo "senza stato", il che significa che ogni volta che un client recupera una pagina Web, il client apre una connessione separata al server Web e il server automaticamente non conserva alcun record della precedente richiesta del client.

Esistono ancora tre modi per mantenere la sessione tra il client Web e il server Web:

Biscotti

Un server web può assegnare un ID di sessione univoco come cookie a ciascun client web e per le richieste successive dal client possono essere riconosciuti utilizzando il cookie ricevuto.

Questo potrebbe non essere un modo efficace perché molte volte il browser non supporta un cookie, quindi non consiglierei di utilizzare questa procedura per mantenere le sessioni.

Campi modulo nascosti

Un server web può inviare un campo modulo HTML nascosto insieme a un ID sessione univoco come segue:

<input type = "hidden" name = "sessionid" value = "12345">

Questa voce significa che, quando il modulo viene inviato, il nome e il valore specificati vengono inclusi automaticamente nei dati GET o POST. Ogni volta che il browser Web invia una richiesta, il valore session_id può essere utilizzato per tenere traccia di diversi browser Web.

Questo potrebbe essere un modo efficace per tenere traccia della sessione, ma fare clic su un normale collegamento ipertestuale (<A HREF...>) non comporta l'invio di un modulo, quindi i campi del modulo nascosti non possono supportare il monitoraggio della sessione generale.

Riscrittura URL

È possibile aggiungere alcuni dati aggiuntivi alla fine di ogni URL che identifica la sessione e il server può associare quell'identificatore di sessione ai dati che ha memorizzato su quella sessione.

Ad esempio, con http://tutorialspoint.com/file.htm;sessionid = 12345, l'identificativo di sessione è allegato come sessionid = 12345 a cui è possibile accedere dal server web per identificare il client.

La riscrittura degli URL è un modo migliore per mantenere le sessioni e funziona anche quando i browser non supportano i cookie. Lo svantaggio della riscrittura dell'URL è che dovresti generare ogni URL in modo dinamico per assegnare un ID di sessione, anche nel caso di una semplice pagina HTML statica.

L'oggetto HttpSession

Oltre ai tre modi sopra menzionati, servlet fornisce l'interfaccia HttpSession che fornisce un modo per identificare un utente attraverso più di una richiesta di pagina o visita a un sito Web e per memorizzare le informazioni su quell'utente.

Il contenitore servlet utilizza questa interfaccia per creare una sessione tra un client HTTP e un server HTTP. La sessione persiste per un periodo di tempo specificato, attraverso più di una connessione o richiesta di pagina da parte dell'utente.

Si otterrebbe l'oggetto HttpSession chiamando il metodo pubblico getSession() di HttpServletRequest, come di seguito -

HttpSession session = request.getSession();

È necessario chiamare request.getSession () prima di inviare qualsiasi contenuto del documento al client. Ecco un riepilogo dei metodi importanti disponibili tramite l'oggetto HttpSession:

Sr.No. Metodo e descrizione
1

public Object getAttribute(String name)

Questo metodo restituisce l'oggetto associato con il nome specificato in questa sessione o null se nessun oggetto è associato al nome.

2

public Enumeration getAttributeNames()

Questo metodo restituisce un'enumerazione di oggetti String contenente i nomi di tutti gli oggetti associati a questa sessione.

3

public long getCreationTime()

Questo metodo restituisce l'ora in cui è stata creata questa sessione, misurata in millisecondi dalla mezzanotte del 1 gennaio 1970 GMT.

4

public String getId()

Questo metodo restituisce una stringa contenente l'identificatore univoco assegnato a questa sessione.

5

public long getLastAccessedTime()

Questo metodo restituisce l'ora dell'ultimo accesso della sessione, nel formato di millisecondi dalla mezzanotte del 1 gennaio 1970 GMT

6

public int getMaxInactiveInterval()

Questo metodo restituisce l'intervallo di tempo massimo (secondi) durante il quale il contenitore servlet manterrà la sessione aperta tra gli accessi del client.

7

public void invalidate()

Questo metodo invalida questa sessione e svincola tutti gli oggetti ad essa associati.

8

public boolean isNew(

Questo metodo restituisce true se il client non è ancora a conoscenza della sessione o se il client sceglie di non partecipare alla sessione.

9

public void removeAttribute(String name)

Questo metodo rimuove l'oggetto associato con il nome specificato da questa sessione.

10

public void setAttribute(String name, Object value)

Questo metodo associa un oggetto a questa sessione, utilizzando il nome specificato.

11

public void setMaxInactiveInterval(int interval)

Questo metodo specifica il tempo, in secondi, tra le richieste del client prima che il contenitore servlet invalidi questa sessione.

Esempio di monitoraggio della sessione

Questo esempio descrive come usare l'oggetto HttpSession per scoprire l'ora di creazione e l'ora dell'ultimo accesso per una sessione. Assoceremo una nuova sessione alla richiesta se non ne esiste già una.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
 
// Extend HttpServlet class
public class SessionTrack extends HttpServlet {
 
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
         
      // Create a session object if it is already not  created.
      HttpSession session = request.getSession(true);
         
      // Get session creation time.
      Date createTime = new Date(session.getCreationTime());
         
      // Get last access time of this web page.
      Date lastAccessTime = new Date(session.getLastAccessedTime());

      String title = "Welcome Back to my website";
      Integer visitCount = new Integer(0);
      String visitCountKey = new String("visitCount");
      String userIDKey = new String("userID");
      String userID = new String("ABCD");

      // Check if this is new comer on your web page.
      if (session.isNew()) {
         title = "Welcome to my website";
         session.setAttribute(userIDKey, userID);
      } else {
         visitCount = (Integer)session.getAttribute(visitCountKey);
         visitCount = visitCount + 1;
         userID = (String)session.getAttribute(userIDKey);
      }
      session.setAttribute(visitCountKey,  visitCount);

      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();

      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " +
         "transitional//en\">\n";

      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<h2 align = \"center\">Session Infomation</h2>\n" +
               "<table border = \"1\" align = \"center\">\n" +
                  
                  "<tr bgcolor = \"#949494\">\n" +
                     "  <th>Session info</th><th>value</th>
                  </tr>\n" +
                     
                  "<tr>\n" +
                     "  <td>id</td>\n" +
                     "  <td>" + session.getId() + "</td>
                  </tr>\n" +
                  
                  "<tr>\n" +
                     "  <td>Creation Time</td>\n" +
                     "  <td>" + createTime + "  </td>
                  </tr>\n" +
                  
                  "<tr>\n" +
                     "  <td>Time of Last Access</td>\n" +
                     "  <td>" + lastAccessTime + "  </td>
                  </tr>\n" +
                  
                  "<tr>\n" +
                     "  <td>User ID</td>\n" +
                     "  <td>" + userID + "  </td>
                  </tr>\n" +
                  
                  "<tr>\n" +
                     "  <td>Number of visits</td>\n" +
                     "  <td>" + visitCount + "</td>
                  </tr>\n" +
               "</table>\n" +
            "</body>
         </html>"
      );
   }
}

Compila il servlet sopra SessionTracke creare la voce appropriata nel file web.xml. L'esecuzione di http: // localhost: 8080 / SessionTrack visualizzerà il seguente risultato quando verrà eseguito per la prima volta:

Welcome to my website

Session Infomation

Session info value
id 0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access Tue Jun 08 17:26:40 GMT+04:00 2010
User ID ABCD
Number of visits 0

Ora prova a eseguire lo stesso servlet per la seconda volta, visualizzerà il seguente risultato.

Welcome Back to my website

Session Infomation

info type value
id 0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access Tue Jun 08 17:26:40 GMT+04:00 2010
User ID ABCD
Number of visits 1

Eliminazione dei dati di sessione

Quando hai finito con i dati della sessione di un utente, hai diverse opzioni:

  • Remove a particular attribute- È possibile chiamare il metodo public void removeAttribute (String name) per eliminare il valore associato a una particolare chiave.

  • Delete the whole session- Puoi chiamare il metodo public void invalidate () per scartare un'intera sessione.

  • Setting Session timeout- Puoi chiamare il metodo public void setMaxInactiveInterval (int interval) per impostare il timeout per una sessione individualmente.

  • Log the user out - I server che supportano i servlet 2.4, puoi chiamare logout per disconnettere il client dal server Web e invalidare tutte le sessioni appartenenti a tutti gli utenti.

  • web.xml Configuration - Se si utilizza Tomcat, oltre ai metodi sopra menzionati, è possibile configurare il timeout della sessione nel file web.xml come segue.

<session-config>
   <session-timeout>15</session-timeout>
</session-config>

Il timeout è espresso in minuti e sostituisce il timeout predefinito che è di 30 minuti in Tomcat.

Il metodo getMaxInactiveInterval () in un servlet restituisce il periodo di timeout per quella sessione in secondi. Quindi, se la tua sessione è configurata in web.xml per 15 minuti, getMaxInactiveInterval () restituisce 900.

Questo tutorial presuppone che tu abbia una comprensione del funzionamento dell'applicazione JDBC. Prima di iniziare con l'accesso al database tramite un servlet, assicurarsi di avere una corretta configurazione dell'ambiente JDBC insieme a un database.

Per maggiori dettagli su come accedere al database utilizzando JDBC e la sua configurazione dell'ambiente, puoi seguire il nostro Tutorial JDBC .

Per iniziare con il concetto di base, creiamo una semplice tabella e creiamo pochi record in quella tabella come segue:

Crea tabella

Per creare il file Employees tabella nel database TEST, utilizzare i seguenti passaggi:

Passo 1

Apri un file Command Prompt e passare alla directory di installazione come segue:

C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>

Passo 2

Accedi al database come segue

C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>

Passaggio 3

Crea la tabella Employee in TEST database come segue -

mysql> use TEST;
mysql> create table Employees (
   id int not null,
   age int not null,
   first varchar (255),
   last varchar (255)
);
Query OK, 0 rows affected (0.08 sec)
mysql>

Crea record di dati

Infine crei alcuni record nella tabella Employee come segue:

mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)
 
mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)
 
mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)
 
mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)
 
mysql>

Accesso a un database

Ecco un esempio che mostra come accedere al database TEST utilizzando Servlet.

// Loading required libraries
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
 
public class DatabaseAccess extends HttpServlet{

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
   
      // JDBC driver name and database URL
      static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
      static final String DB_URL="jdbc:mysql://localhost/TEST";

      //  Database credentials
      static final String USER = "root";
      static final String PASS = "password";

      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      String title = "Database Result";
      
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n" +
         "<body bgcolor = \"#f0f0f0\">\n" +
         "<h1 align = \"center\">" + title + "</h1>\n");
      try {
         // Register JDBC driver
         Class.forName("com.mysql.jdbc.Driver");

         // Open a connection
         Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);

         // Execute SQL query
         Statement stmt = conn.createStatement();
         String sql;
         sql = "SELECT id, first, last, age FROM Employees";
         ResultSet rs = stmt.executeQuery(sql);

         // Extract data from result set
         while(rs.next()){
            //Retrieve by column name
            int id  = rs.getInt("id");
            int age = rs.getInt("age");
            String first = rs.getString("first");
            String last = rs.getString("last");

            //Display values
            out.println("ID: " + id + "<br>");
            out.println(", Age: " + age + "<br>");
            out.println(", First: " + first + "<br>");
            out.println(", Last: " + last + "<br>");
         }
         out.println("</body></html>");

         // Clean-up environment
         rs.close();
         stmt.close();
         conn.close();
      } catch(SQLException se) {
         //Handle errors for JDBC
         se.printStackTrace();
      } catch(Exception e) {
         //Handle errors for Class.forName
         e.printStackTrace();
      } finally {
         //finally block used to close resources
         try {
            if(stmt!=null)
               stmt.close();
         } catch(SQLException se2) {
         } // nothing we can do
         try {
            if(conn!=null)
            conn.close();
         } catch(SQLException se) {
            se.printStackTrace();
         } //end finally try
      } //end try
   }
}

Ora compiliamo il servlet sopra e creiamo le seguenti voci in web.xml

....
<servlet>
   <servlet-name>DatabaseAccess</servlet-name>
   <servlet-class>DatabaseAccess</servlet-class>
</servlet>
 
<servlet-mapping>
   <servlet-name>DatabaseAccess</servlet-name>
   <url-pattern>/DatabaseAccess</url-pattern>
</servlet-mapping>
....

Ora chiama questo servlet utilizzando l'URL http: // localhost: 8080 / DatabaseAccess che visualizzerebbe la seguente risposta:

Database Result

ID: 100, Age: 18, First: Zara, Last: Ali ID: 101, Age: 25, First: Mahnaz, Last: Fatma ID: 102, Age: 30, First: Zaid, Last: Khan ID: 103, Age: 28, First: Sumit, Last: Mittal

È possibile utilizzare un servlet con un tag del modulo HTML per consentire agli utenti di caricare file sul server. Un file caricato può essere un file di testo o un file di immagine o qualsiasi documento.

Creazione di un modulo di caricamento file

Il seguente codice HTM di seguito crea un modulo di caricamento. Di seguito sono riportati i punti importanti da annotare:

  • Il modulo method l'attributo dovrebbe essere impostato su POST il metodo e il metodo GET non possono essere utilizzati

  • Il modulo enctype l'attributo dovrebbe essere impostato su multipart/form-data.

  • Il modulo actionl'attributo deve essere impostato su un file servlet che gestisca il caricamento dei file sul server di backend. L'esempio seguente sta usandoUploadServlet servlet per caricare il file.

  • Per caricare un singolo file devi utilizzare un singolo tag <input ... /> con attributo type = "file". Per consentire il caricamento di più file, includi più di un tag di input con valori diversi per l'attributo name. Il browser associa un pulsante Sfoglia a ciascuno di essi.

<html>
   <head>
      <title>File Uploading Form</title>
   </head>
   
   <body>
      <h3>File Upload:</h3>
      Select a file to upload: <br />
      <form action = "UploadServlet" method = "post" enctype = "multipart/form-data">
         <input type = "file" name = "file" size = "50" />
         <br />
         <input type = "submit" value = "Upload File" />
      </form>
   </body>
</html>

Questo mostrerà il seguente risultato che consentirebbe di selezionare un file dal PC locale e quando l'utente farebbe clic su "Carica file", il modulo verrà inviato insieme al file selezionato -

File Upload: 
Select a file to upload: 


NOTE: This is just dummy form and would not work.

Scrittura del servlet di backend

Di seguito è riportato il servlet UploadServletche si occuperebbe di accettare il file caricato e di memorizzarlo nella directory <Tomcat-installation-directory> / webapps / data. Questo nome di directory può anche essere aggiunto utilizzando una configurazione esterna come un filecontext-param elemento in web.xml come segue:

<web-app>
   ....
   <context-param> 
      <description>Location to store uploaded file</description> 
      <param-name>file-upload</param-name> 
      <param-value>
         c:\apache-tomcat-5.5.29\webapps\data\
     </param-value> 
   </context-param>
   ....
</web-app>

Di seguito è riportato il codice sorgente per UploadServlet che può gestire il caricamento di più file alla volta. Prima di procedere devi assicurarti quanto segue:

  • L'esempio seguente dipende da FileUpload, quindi assicurati di avere l'ultima versione di commons-fileupload.x.x.jarfile nel tuo classpath. Puoi scaricarlo dahttps://commons.apache.org/fileupload/.

  • FileUpload dipende da Commons IO, quindi assicurati di avere l'ultima versione di commons-io-x.x.jarfile nel tuo classpath. Puoi scaricarlo dahttps://commons.apache.org/io/.

  • Durante il test del seguente esempio, è necessario caricare un file di dimensioni inferiori a maxFileSize altrimenti il ​​file non verrà caricato.

  • Assicurati di aver creato le directory c: \ temp ec: \ apache-tomcat8.0.28 \ webapps \ data con largo anticipo.

// Import required java libraries
import java.io.*;
import java.util.*;
 
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.output.*;

public class UploadServlet extends HttpServlet {
   
   private boolean isMultipart;
   private String filePath;
   private int maxFileSize = 50 * 1024;
   private int maxMemSize = 4 * 1024;
   private File file ;

   public void init( ){
      // Get the file location where it would be stored.
      filePath = getServletContext().getInitParameter("file-upload"); 
   }
   
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, java.io.IOException {
   
      // Check that we have a file upload request
      isMultipart = ServletFileUpload.isMultipartContent(request);
      response.setContentType("text/html");
      java.io.PrintWriter out = response.getWriter( );
   
      if( !isMultipart ) {
         out.println("<html>");
         out.println("<head>");
         out.println("<title>Servlet upload</title>");  
         out.println("</head>");
         out.println("<body>");
         out.println("<p>No file uploaded</p>"); 
         out.println("</body>");
         out.println("</html>");
         return;
      }
  
      DiskFileItemFactory factory = new DiskFileItemFactory();
   
      // maximum size that will be stored in memory
      factory.setSizeThreshold(maxMemSize);
   
      // Location to save data that is larger than maxMemSize.
      factory.setRepository(new File("c:\\temp"));

      // Create a new file upload handler
      ServletFileUpload upload = new ServletFileUpload(factory);
   
      // maximum file size to be uploaded.
      upload.setSizeMax( maxFileSize );

      try { 
         // Parse the request to get file items.
         List fileItems = upload.parseRequest(request);
	
         // Process the uploaded file items
         Iterator i = fileItems.iterator();

         out.println("<html>");
         out.println("<head>");
         out.println("<title>Servlet upload</title>");  
         out.println("</head>");
         out.println("<body>");
   
         while ( i.hasNext () ) {
            FileItem fi = (FileItem)i.next();
            if ( !fi.isFormField () ) {
               // Get the uploaded file parameters
               String fieldName = fi.getFieldName();
               String fileName = fi.getName();
               String contentType = fi.getContentType();
               boolean isInMemory = fi.isInMemory();
               long sizeInBytes = fi.getSize();
            
               // Write the file
               if( fileName.lastIndexOf("\\") >= 0 ) {
                  file = new File( filePath + fileName.substring( fileName.lastIndexOf("\\"))) ;
               } else {
                  file = new File( filePath + fileName.substring(fileName.lastIndexOf("\\")+1)) ;
               }
               fi.write( file ) ;
               out.println("Uploaded Filename: " + fileName + "<br>");
            }
         }
         out.println("</body>");
         out.println("</html>");
         } catch(Exception ex) {
            System.out.println(ex);
         }
      }
      
      public void doGet(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, java.io.IOException {

         throw new ServletException("GET method used with " +
            getClass( ).getName( )+": POST method required.");
      }
   }
}

Compilare ed eseguire servlet

Compilare il servlet UploadServlet sopra e creare la voce richiesta nel file web.xml come segue.

<servlet>
   <servlet-name>UploadServlet</servlet-name>
   <servlet-class>UploadServlet</servlet-class>
</servlet>

<servlet-mapping>
   <servlet-name>UploadServlet</servlet-name>
   <url-pattern>/UploadServlet</url-pattern>
</servlet-mapping>

Ora prova a caricare i file utilizzando il modulo HTML che hai creato sopra. Quando provi http: // localhost: 8080 / UploadFile.htm, verrà visualizzato il seguente risultato che ti aiuterà a caricare qualsiasi file dalla tua macchina locale.

File Upload: 

Select a file to upload:


Se il tuo script servlet funziona correttamente, il tuo file dovrebbe essere caricato nella directory c: \ apache-tomcat8.0.28 \ webapps \ data \.

Uno dei vantaggi più importanti dell'utilizzo di Servlet è che è possibile utilizzare la maggior parte dei metodi disponibili nel core Java. Questo tutorial ti porterà attraverso Java fornitoDate classe disponibile in java.util pacchetto, questa classe incapsula la data e l'ora correnti.

La classe Date supporta due costruttori. Il primo costruttore inizializza l'oggetto con la data e l'ora correnti.

Date( )

Il seguente costruttore accetta un argomento che equivale al numero di millisecondi trascorsi dalla mezzanotte del 1 gennaio 1970

Date(long millisec)

Una volta che hai un oggetto Date disponibile, puoi chiamare uno dei seguenti metodi di supporto per giocare con le date:

Sr.No. Metodi e descrizione
1

boolean after(Date date)

Restituisce true se l'oggetto Date che richiama contiene una data successiva a quella specificata da date, altrimenti restituisce false.

2

boolean before(Date date)

Restituisce true se l'oggetto Date che richiama contiene una data precedente a quella specificata da date, altrimenti restituisce false.

3

Object clone( )

Duplica l'oggetto Date che richiama.

4

int compareTo(Date date)

Confronta il valore dell'oggetto invocante con quello di date. Restituisce 0 se i valori sono uguali. Restituisce un valore negativo se l'oggetto che richiama è precedente alla data. Restituisce un valore positivo se l'oggetto che richiama è successivo alla data.

5

int compareTo(Object obj)

Funziona in modo identico a compareTo (Date) se obj è della classe Date. In caso contrario, genera un'eccezione ClassCastException.

6

boolean equals(Object date)

Restituisce true se l'oggetto Date che richiama contiene la stessa ora e data di quella specificata da date, altrimenti restituisce false.

7

long getTime( )

Restituisce il numero di millisecondi trascorsi dal 1 gennaio 1970.

8

int hashCode( )

Restituisce un codice hash per l'oggetto che richiama.

9

void setTime(long time)

Imposta l'ora e la data come specificato da time, che rappresenta il tempo trascorso in millisecondi dalla mezzanotte del 1 gennaio 1970.

10

String toString( )

Converte l'oggetto Date che richiama in una stringa e restituisce il risultato.

Recupero di data e ora correnti

È molto facile ottenere la data e l'ora correnti in Java Servlet. È possibile utilizzare un semplice oggetto Date con il metodo toString () per stampare la data e l'ora correnti come segue:

// Import required java libraries
import java.io.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
 
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
 
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");
 
      PrintWriter out = response.getWriter();
      String title = "Display Current Date & Time";
      Date date = new Date();
      String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<h2 align = \"center\">" + date.toString() + "</h2>\n" +
            "</body>
         </html>"
      );
   }
}

Ora compiliamo il servlet sopra e creiamo le voci appropriate in web.xml, quindi chiamiamo questo servlet utilizzando l'URL http: // localhost: 8080 / CurrentDate. Ciò produrrebbe il seguente risultato:

Display Current Date & Time

Mon Jun 21 21:46:49 GMT+04:00 2010

Prova ad aggiornare l'URL http: // localhost: 8080 / CurrentDate e troverai la differenza in secondi ogni volta che aggiorni.

Confronto delle date

Come accennato in precedenza, puoi utilizzare tutti i metodi Java disponibili nel tuo Servlet. Nel caso in cui sia necessario confrontare due date, di seguito sono riportati i metodi:

  • È possibile utilizzare getTime () per ottenere il numero di millisecondi trascorsi dalla mezzanotte del 1 gennaio 1970 per entrambi gli oggetti e quindi confrontare questi due valori.

  • È possibile utilizzare i metodi before (), after () ed equals (). Poiché il 12 del mese precede il 18, ad esempio, new Date (99, 2, 12) .before (new Date (99, 2, 18)) restituisce true.

  • È possibile utilizzare il metodo compareTo (), definito dall'interfaccia Comparable e implementato da Date.

Formattazione della data utilizzando SimpleDateFormat

SimpleDateFormat è una classe concreta per la formattazione e l'analisi delle date in modo sensibile alla localizzazione. SimpleDateFormat consente di iniziare scegliendo qualsiasi modello definito dall'utente per la formattazione della data e dell'ora.

Modifichiamo l'esempio sopra come segue:

// Import required java libraries
import java.io.*;
import java.text.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
 
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
 
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");
 
      PrintWriter out = response.getWriter();
      String title = "Display Current Date & Time";
      Date dNow = new Date( );
      SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
      String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<h2 align = \"center\">" + ft.format(dNow) + "</h2>\n" +
            "</body>
         </html>"
      );
   }
}

Compilare nuovamente il servlet sopra riportato e quindi chiamare questo servlet utilizzando l'URL http: // localhost: 8080 / CurrentDate. Ciò produrrebbe il seguente risultato:

Display Current Date & Time

Mon 2010.06.21 at 10:06:44 PM GMT+04:00

Codici di formato DateFormat semplici

Per specificare il formato dell'ora, utilizzare una stringa del modello dell'ora. In questo modello, tutte le lettere ASCII sono riservate come lettere del modello, che sono definite come segue:

Personaggio Descrizione Esempio
G Designatore di epoca ANNO DOMINI
y Anno in quattro cifre 2001
M Mese nell'anno Luglio o 07
d Giorno in mese 10
h Ora AM / PM (1 ~ 12) 12
H Ora nel giorno (0 ~ 23) 22
m Minuto in ora 30
S Secondo in minuto 55
S Millisecondo 234
E Giorno in settimana martedì
D Giorno dell'anno 360
F Giorno della settimana nel mese 2 (secondo mercoledì di luglio)
w Settimana nell'anno 40
W Settimana al mese 1
un Indicatore AM / PM PM
K Ora nel giorno (1 ~ 24) 24
K Ora AM / PM (0 ~ 11) 10
z Fuso orario Ora solare orientale
' Fuga per il testo Delimitatore
" Virgoletta singola "

Per un elenco completo dei metodi disponibili costanti per manipolare la data, è possibile fare riferimento alla documentazione Java standard.

Il reindirizzamento della pagina è una tecnica in cui il client viene inviato a una nuova posizione diversa da quella richiesta. Il reindirizzamento della pagina viene generalmente utilizzato quando un documento si sposta in una nuova posizione o può essere dovuto al bilanciamento del carico.

Il modo più semplice per reindirizzare una richiesta a un'altra pagina è utilizzare method sendRedirect()dell'oggetto risposta. Di seguito è riportata la firma di questo metodo:

public void HttpServletResponse.sendRedirect(String location) 
throws IOException

Questo metodo restituisce la risposta al browser insieme al codice di stato e alla nuova posizione della pagina. Puoi anche usare i metodi setStatus () e setHeader () insieme per ottenere lo stesso risultato -

.... 
String site = "http://www.newpage.com" ; 
response.setStatus(response.SC_MOVED_TEMPORARILY); 
response.setHeader("Location", site);  
....

Esempio

Questo esempio mostra come un servlet esegue il reindirizzamento della pagina in un'altra posizione -

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

public class PageRedirect extends HttpServlet {
    
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

      // Set response content type
      response.setContentType("text/html");

      // New location to be redirected
      String site = new String("http://www.photofuntoos.com");

      response.setStatus(response.SC_MOVED_TEMPORARILY);
      response.setHeader("Location", site);    
   }
}

Ora compiliamo il servlet sopra e creiamo le seguenti voci in web.xml

....
<servlet>
   <servlet-name>PageRedirect</servlet-name>
   <servlet-class>PageRedirect</servlet-class>
</servlet>

<servlet-mapping>
   <servlet-name>PageRedirect</servlet-name>
   <url-pattern>/PageRedirect</url-pattern>
</servlet-mapping>
....

Ora chiama questo servlet utilizzando l'URL http: // localhost: 8080 / PageRedirect. Questo ti reindirizzerebbe all'URL http://www.photofuntoos.com.

Contatore visite per una pagina Web

Molte volte saresti interessato a conoscere il numero totale di visite su una particolare pagina del tuo sito web. È molto semplice contare questi hit utilizzando un servlet perché il ciclo di vita di un servlet è controllato dal contenitore in cui viene eseguito.

Di seguito sono riportati i passaggi da eseguire per implementare un semplice contatore di visite di pagine basato sul ciclo di vita del servlet:

  • Inizializza una variabile globale nel metodo init ().

  • Aumenta la variabile globale ogni volta che viene chiamato il metodo doGet () o doPost ().

  • Se necessario, è possibile utilizzare una tabella del database per memorizzare il valore della variabile globale nel metodo destroy (). Questo valore può essere letto all'interno del metodo init () quando il servlet verrà inizializzato la prossima volta. Questo passaggio è facoltativo.

  • Se si desidera contare solo gli hit di pagina unici durante una sessione, è possibile utilizzare il metodo isNew () per verificare se la stessa pagina è già stata raggiunta durante quella sessione. Questo passaggio è facoltativo.

  • Puoi visualizzare il valore del contatore globale per mostrare il numero totale di visite sul tuo sito web. Anche questo passaggio è facoltativo.

Qui presumo che il contenitore web non verrà riavviato. Se viene riavviato o il servlet viene distrutto, il contatore di visite verrà ripristinato.

Esempio

Questo esempio mostra come implementare un semplice contatore di visite di pagine:

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

public class PageHitCounter extends HttpServlet {

   private int hitCount; 

   public void init() { 
      // Reset hit counter.
      hitCount = 0;
   } 

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

      // Set response content type
      response.setContentType("text/html");

      // This method executes whenever the servlet is hit 
      // increment hitCount 
      hitCount++; 
      PrintWriter out = response.getWriter();
      String title = "Total Number of Hits";
      String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<h2 align = \"center\">" + hitCount + "</h2>\n" +
            "</body>
         </html>"
      );
   }
   
   public void destroy() { 
      // This is optional step but if you like you
      // can write hitCount value in your database.
   } 
}

Ora compiliamo il servlet sopra e creiamo le seguenti voci in web.xml

<servlet>
   <servlet-name>PageHitCounter</servlet-name>
   <servlet-class>PageHitCounter</servlet-class>
</servlet>

<servlet-mapping>
   <servlet-name>PageHitCounter</servlet-name>
   <url-pattern>/PageHitCounter</url-pattern>
</servlet-mapping>
....

Ora chiama questo servlet utilizzando l'URL http: // localhost: 8080 / PageHitCounter. Ciò aumenterebbe il contatore di uno ogni volta che questa pagina viene aggiornata e verrà visualizzato il seguente risultato:

Total Number of Hits

6

Hit Counter for a Website:

Molte volte saresti interessato a conoscere il numero totale di visite su tutto il tuo sito web. Anche questo è molto semplice in Servlet e possiamo farlo usando i filtri.

Di seguito sono riportati i passaggi da eseguire per implementare un semplice contatore di visite del sito Web basato sul ciclo di vita del filtro:

  • Inizializza una variabile globale nel metodo init () di un filtro.

  • Aumenta la variabile globale ogni volta che viene chiamato il metodo doFilter.

  • Se necessario, è possibile utilizzare una tabella di database per memorizzare il valore della variabile globale nel metodo di filtro destroy (). Questo valore può essere letto all'interno del metodo init () quando il filtro verrà inizializzato la prossima volta. Questo passaggio è facoltativo.

Qui presumo che il contenitore web non verrà riavviato. Se viene riavviato o il servlet viene distrutto, il contatore di visite verrà ripristinato.

Esempio

Questo esempio mostra come implementare un semplice contatore di visite del sito Web:

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

public class SiteHitCounter implements Filter {

   private int hitCount; 

   public void  init(FilterConfig config) throws ServletException {
      // Reset hit counter.
      hitCount = 0;
   }

   public void  doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
      throws java.io.IOException, ServletException {

      // increase counter by one
      hitCount++;

      // Print the counter.
      System.out.println("Site visits count :"+ hitCount );

      // Pass request back down the filter chain
      chain.doFilter(request,response);
   }
   
   public void destroy() { 
      // This is optional step but if you like you
      // can write hitCount value in your database.
   } 
}

Ora compiliamo il servlet sopra e creiamo le seguenti voci in web.xml

....
<filter>
   <filter-name>SiteHitCounter</filter-name>
   <filter-class>SiteHitCounter</filter-class>
</filter>

<filter-mapping>
   <filter-name>SiteHitCounter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
....

Ora chiama qualsiasi URL come URL http: // localhost: 8080 /. Ciò aumenterebbe il contatore di uno ogni volta che una pagina riceve un hit e visualizzerà il seguente messaggio nel registro:

Site visits count : 1
Site visits count : 2
Site visits count : 3
Site visits count : 4
Site visits count : 5
..................

Considera una pagina web che mostra il punteggio del gioco in tempo reale o lo stato del mercato azionario o la razione di cambio valuta. Per tutti questi tipi di pagine, è necessario aggiornare regolarmente la pagina Web utilizzando il pulsante di aggiornamento o ricarica con il browser.

Java Servlet semplifica questo lavoro fornendo un meccanismo in cui è possibile creare una pagina Web in modo tale che venga aggiornata automaticamente dopo un determinato intervallo.

Il modo più semplice per aggiornare una pagina web è usare il metodo setIntHeader()dell'oggetto risposta. Di seguito è riportata la firma di questo metodo:

public void setIntHeader(String header, int headerValue)

Questo metodo restituisce l'intestazione "Aggiorna" al browser insieme a un valore intero che indica l'intervallo di tempo in secondi.

Esempio di aggiornamento automatico della pagina

Questo esempio mostra come un servlet esegue l'aggiornamento automatico della pagina utilizzando setIntHeader() metodo da impostare Refresh intestazione.

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
 
// Extend HttpServlet class
public class Refresh extends HttpServlet {
 
   // Method to handle GET method request.
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set refresh, autoload time as 5 seconds
      response.setIntHeader("Refresh", 5);
 
      // Set response content type
      response.setContentType("text/html");
 
      // Get current time
      Calendar calendar = new GregorianCalendar();
      String am_pm;
      int hour = calendar.get(Calendar.HOUR);
      int minute = calendar.get(Calendar.MINUTE);
      int second = calendar.get(Calendar.SECOND);
      
      if(calendar.get(Calendar.AM_PM) == 0)
        am_pm = "AM";
      else
        am_pm = "PM";
 
      String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
    
      PrintWriter out = response.getWriter();
      String title = "Auto Page Refresh using Servlet";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
         "<head><title>" + title + "</title></head>\n"+
         "<body bgcolor = \"#f0f0f0\">\n" +
         "<h1 align = \"center\">" + title + "</h1>\n" +
         "<p>Current Time is: " + CT + "</p>\n"
      );
   }
   
   // Method to handle POST method request.
   public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      doGet(request, response);
   }
}

Ora compiliamo il servlet sopra e creiamo le seguenti voci in web.xml

....
 <servlet>
     <servlet-name>Refresh</servlet-name>
     <servlet-class>Refresh</servlet-class>
 </servlet>
 
 <servlet-mapping>
     <servlet-name>Refresh</servlet-name>
     <url-pattern>/Refresh</url-pattern>
 </servlet-mapping>
....

Ora chiama questo servlet utilizzando l'URL http: // localhost: 8080 / Refresh che visualizzerà l'ora corrente del sistema ogni 5 secondi come segue. Basta eseguire il servlet e attendere di vedere il risultato -

Auto Page Refresh using Servlet

Current Time is: 9:44:50 PM

Inviare un'e-mail utilizzando il tuo a Servlet è abbastanza semplice, ma per iniziare dovresti averlo JavaMail API e Java Activation Framework (JAF) installato sulla tua macchina.

  • È possibile scaricare l'ultima versione di JavaMail (Versione 1.2) dal sito Web standard di Java.

  • È possibile scaricare l'ultima versione di JAF (versione 1.1.1) dal sito Web standard di Java.

Scarica e decomprimi questi file, nelle directory di primo livello appena create troverai una serie di file jar per entrambe le applicazioni. Devi aggiungeremail.jar e activation.jar file nel tuo CLASSPATH.

Invia una semplice email

Ecco un esempio per inviare una semplice email dalla tua macchina. Qui si presume che il tuo filelocalhostè connesso a Internet e in grado di inviare un'e-mail. Allo stesso tempo assicurati che tutti i file jar dal pacchetto Java Email API e dal pacchetto JAF siano disponibili in CLASSPATH.

// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
 
public class SendEmail extends HttpServlet {

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";
 
      // Sender's email ID needs to be mentioned
      String from = "[email protected]";
 
      // Assuming you are sending email from localhost
      String host = "localhost";
 
      // Get system properties
      Properties properties = System.getProperties();
 
      // Setup mail server
      properties.setProperty("mail.smtp.host", host);
 
      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);
      
      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);
         
         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));
         
         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
         
         // Set Subject: header field
         message.setSubject("This is the Subject Line!");
         
         // Now set the actual message
         message.setText("This is actual message");
         
         // Send message
         Transport.send(message);
         String title = "Send Email";
         String res = "Sent message successfully....";
         String docType =
            "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
         
         out.println(docType +
            "<html>\n" +
               "<head><title>" + title + "</title></head>\n" +
               "<body bgcolor = \"#f0f0f0\">\n" +
                  "<h1 align = \"center\">" + title + "</h1>\n" +
                  "<p align = \"center\">" + res + "</p>\n" +
               "</body>
            </html>"
         );
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Ora compiliamo il servlet sopra e creiamo le seguenti voci in web.xml

....
 <servlet>
   <servlet-name>SendEmail</servlet-name>
   <servlet-class>SendEmail</servlet-class>
</servlet>
 
<servlet-mapping>
   <servlet-name>SendEmail</servlet-name>
   <url-pattern>/SendEmail</url-pattern>
</servlet-mapping>
....

Ora chiama questo servlet utilizzando l'URL http: // localhost: 8080 / SendEmail che invierebbe un'e-mail al dato ID e -mail [email protected] e visualizzerebbe la seguente risposta:

Send Email

Sent message successfully....

Se desideri inviare un'e-mail a più destinatari, verranno utilizzati i seguenti metodi per specificare più ID e-mail:

void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingException

Ecco la descrizione dei parametri:

  • type- Questo sarebbe impostato su TO, CC o BCC. Qui CC rappresenta Carbon Copy e BCC rappresenta Black Carbon Copy. Esempio Message.RecipientType.TO

  • addresses- Questa è la matrice dell'ID e-mail. Dovresti usare il metodo InternetAddress () mentre specifichi gli ID email.

Invia un'e-mail HTML

Ecco un esempio per inviare un'e-mail HTML dalla tua macchina. Qui si presume che il tuo filelocalhostè connesso a Internet e in grado di inviare un'e-mail. Allo stesso tempo, assicurati che tutti i file jar dal pacchetto Java Email API e dal pacchetto JAF siano disponibili in CLASSPATH.

Questo esempio è molto simile al precedente, tranne che qui stiamo usando il metodo setContent () per impostare il contenuto il cui secondo argomento è "text / html" per specificare che il contenuto HTML è incluso nel messaggio.

Usando questo esempio, puoi inviare un contenuto HTML grande quanto ti piace.

// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
 
public class SendEmail extends HttpServlet {
    
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";
 
      // Sender's email ID needs to be mentioned
      String from = "[email protected]";
 
      // Assuming you are sending email from localhost
      String host = "localhost";
 
      // Get system properties
      Properties properties = System.getProperties();
 
      // Setup mail server
      properties.setProperty("mail.smtp.host", host);
 
      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);
      
      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();

      try {
         
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);
         
         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));
         
         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Send the actual HTML message, as big as you like
         message.setContent("<h1>This is actual message</h1>", "text/html" );
         
         // Send message
         Transport.send(message);
         String title = "Send Email";
         String res = "Sent message successfully....";
         String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
         
         out.println(docType +
            "<html>\n" +
               "<head><title>" + title + "</title></head>\n" +
               "<body bgcolor = \"#f0f0f0\">\n" +
                  "<h1 align = \"center\">" + title + "</h1>\n" +
                  "<p align = \"center\">" + res + "</p>\n" +
               "</body>
            </html>"
         );
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compila ed esegui il servlet sopra per inviare un messaggio HTML su un determinato ID email.

Invia allegato in e-mail

Ecco un esempio per inviare un'e-mail con allegato dal tuo computer. Qui si presume che il tuo filelocalhost è connesso a Internet e in grado di inviare un'e-mail.

// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
 
public class SendEmail extends HttpServlet {

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";
 
      // Sender's email ID needs to be mentioned
      String from = "[email protected]";
 
      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();
 
      // Setup mail server
      properties.setProperty("mail.smtp.host", host);
 
      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);
      
	  // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);
 
         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));
 
         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
 
         // Set Subject: header field
         message.setSubject("This is the Subject Line!");
 
         // Create the message part 
         BodyPart messageBodyPart = new MimeBodyPart();
 
         // Fill the message
         messageBodyPart.setText("This is message body");
         
         // Create a multipar message
         Multipart multipart = new MimeMultipart();
 
         // Set text message part
         multipart.addBodyPart(messageBodyPart);
 
         // Part two is attachment
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);
 
         // Send the complete message parts
         message.setContent(multipart );
 
         // Send message
         Transport.send(message);
         String title = "Send Email";
         String res = "Sent message successfully....";
         String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
         
         out.println(docType +
            "<html>\n" +
               "<head><title>" + title + "</title></head>\n" +
               "<body bgcolor = \"#f0f0f0\">\n" +
                  "<h1 align = \"center\">" + title + "</h1>\n" +
                  "<p align = \"center\">" + res + "</p>\n" +
               "</body>
            </html>"
         );
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compila ed esegui il servlet sopra per inviare un file come allegato insieme a un messaggio su un determinato ID email.

Parte autenticazione utente

Se è necessario fornire l'ID utente e la password al server di posta elettronica per scopi di autenticazione, è possibile impostare queste proprietà come segue:

props.setProperty("mail.user", "myuser");
 props.setProperty("mail.password", "mypwd");

Il resto del meccanismo di invio delle e-mail rimarrebbe come spiegato sopra.

La struttura dell'applicazione Web che coinvolge la sottodirectory WEB-INF è standard per tutte le applicazioni Web Java e specificata dalla specifica API servlet. Dato un nome di directory di primo livello di myapp. Ecco come appare questa struttura di directory:

/myapp
   /images
   /WEB-INF
      /classes
      /lib

La sottodirectory WEB-INF contiene il descrittore di distribuzione dell'applicazione, denominato web.xml. Tutti i file HTML dovrebbero essere conservati nella directory di primo livello che è myapp . Per l'utente amministratore, troverai la directory ROOT come directory principale.

Creazione di servlet nei pacchetti

La directory WEB-INF / classes contiene tutte le classi servlet e altri file di classe, in una struttura che corrisponde al nome del loro pacchetto. Ad esempio, se hai un nome di classe completo dicom.myorg.MyServlet, allora questa classe servlet deve trovarsi nella seguente directory -

/myapp/WEB-INF/classes/com/myorg/MyServlet.class

Di seguito è riportato l'esempio per creare la classe MyServlet con un nome di pacchetto com.myorg

// Name your package
package com.myorg;  

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public class MyServlet extends HttpServlet {
 
   private String message;
 
   public void init() throws ServletException {
      // Do required initialization
      message = "Hello World";
   }
 
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");
 
      // Actual logic goes here.
      PrintWriter out = response.getWriter();
      out.println("<h1>" + message + "</h1>");
   }

   public void destroy() {
      // do nothing.
   }
}

Compilazione di servlet nei pacchetti

Non c'è niente di molto diverso per compilare una classe disponibile in package. Il modo più semplice è mantenere il tuo file java in un percorso completo, come menzionato sopra, la classe sarebbe mantenuta in com.myorg. Dovresti anche aggiungere questa directory in CLASSPATH.

Supponendo che il tuo ambiente sia configurato correttamente, entra <Tomcat-installationdirectory>/ webapps / ROOT / WEB-INF / classes e compilare MyServlet.java come segue

$ javac MyServlet.java

Se il servlet dipende da altre librerie, è necessario includere anche quei file JAR nel CLASSPATH. Ho incluso solo il file JAR servlet-api.jar perché non sto utilizzando nessun'altra libreria nel programma Hello World.

Questa riga di comando utilizza il compilatore javac integrato fornito con JDK (Java Software Development Kit) di Sun Microsystems. Affinché questo comando funzioni correttamente, è necessario includere la posizione dell'SDK Java che si sta utilizzando nella variabile di ambiente PATH.

Se tutto va bene, la compilazione di cui sopra produrrebbe MyServlet.classfile nella stessa directory. La prossima sezione spiegherebbe come un servlet compilato verrebbe distribuito in produzione.

Distribuzione servlet in pacchetto

Per impostazione predefinita, un'applicazione servlet si trova nel percorso <Tomcat-installationdirectory> / webapps / ROOT e il file di classe risiederebbe in <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.

Se hai un nome di classe completo di com.myorg.MyServlet, quindi questa classe servlet deve trovarsi in WEB-INF / classes / com / myorg / MyServlet.class e dovresti creare le seguenti voci in web.xml file situato in <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF /

<servlet>
   <servlet-name>MyServlet</servlet-name>
   <servlet-class>com.myorg.MyServlet</servlet-class>
</servlet>
 
<servlet-mapping>
   <servlet-name>MyServlet</servlet-name>
   <url-pattern>/MyServlet</url-pattern>
</servlet-mapping>

Voci sopra da creare all'interno dei tag <web-app> ... </web-app> disponibili nel file web.xml. Potrebbero esserci varie voci in questa tabella già disponibili, ma non importa.

Hai quasi finito, ora avvia il server Tomcat utilizzando <Directory-installazione- Tomcat> \ bin \ startup.bat (su Windows) o <Directory-installazione- Tomcat> /bin/startup.sh (su Linux / Solaris ecc.) E infine digita http://localhost:8080/MyServletnella casella degli indirizzi del browser. Se tutto va bene, otterrai il seguente risultato:

Hello World

È sempre difficile testare / eseguire il debug di un servlet. I servlet tendono a coinvolgere una grande quantità di interazioni client / server, rendendo gli errori probabili ma difficili da riprodurre.

Ecco alcuni suggerimenti e suggerimenti che possono aiutarti nel tuo debug.

System.out.println ()

System.out.println () è facile da usare come indicatore per verificare se un determinato pezzo di codice viene eseguito o meno. Possiamo anche stampare i valori delle variabili. Inoltre -

  • Poiché l'oggetto System fa parte degli oggetti Java principali, può essere utilizzato ovunque senza la necessità di installare classi aggiuntive. Ciò include Servlet, JSP, RMI, EJB, Beans e classi ordinarie e applicazioni autonome.

  • La tecnica di arresto ai punti di interruzione interrompe la normale esecuzione, quindi richiede più tempo. Considerando che scrivere su System.out non interferisce molto con il normale flusso di esecuzione dell'applicazione, il che lo rende molto prezioso quando il tempismo è cruciale.

Di seguito è riportata la sintassi per utilizzare System.out.println () -

System.out.println("Debugging message");

Tutti i messaggi generati dalla sintassi di cui sopra verrebbero registrati nel file di registro del server web.

Registrazione dei messaggi

È sempre una buona idea utilizzare un metodo di registrazione appropriato per registrare tutti i messaggi di debug, avviso ed errore utilizzando un metodo di registrazione standard. Uso log4J per registrare tutti i messaggi.

L'API Servlet fornisce anche un modo semplice per fornire informazioni utilizzando il metodo log () come segue:

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class ContextLog extends HttpServlet {
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, java.io.IOException {
    
      String par = request.getParameter("par1");
      
      //Call the two ServletContext.log methods
      ServletContext context = getServletContext( );

      if (par == null || par.equals(""))
         //log version with Throwable parameter
         context.log("No message received:", new IllegalStateException("Missing parameter"));
      else
         context.log("Here is the visitor's message: " + par);
      
      response.setContentType("text/html");
      java.io.PrintWriter out = response.getWriter( );
      String title = "Context Log";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + title + "</h1>\n" +
               "<h2 align = \"center\">Messages sent</h2>\n" +
            "</body>
         </html>"
      );
   } //doGet
}

Il ServletContext registra i suoi messaggi di testo nel file di registro del contenitore servlet. Con Tomcat questi log si trovano in <Tomcat-installation-directory> / logs.

I file di registro forniscono un'indicazione di nuovi bug emergenti o la frequenza dei problemi. Per questo motivo è bene utilizzare la funzione log () nella clausola catch delle eccezioni che normalmente non dovrebbero verificarsi.

Utilizzo del debugger JDB

È possibile eseguire il debug dei servlet con gli stessi comandi jdb utilizzati per eseguire il debug di un'applet o di un'applicazione.

Per eseguire il debug di un servlet, eseguiamo il debug di sun.servlet.http.HttpServer e osserviamo attentamente come HttpServer esegue i servlet in risposta alle richieste HTTP effettuate dal browser. Questo è molto simile al modo in cui viene eseguito il debug degli applet. La differenza è che con le applet, il programma di cui si esegue il debug è sun.applet.AppletViewer.

La maggior parte dei debugger nasconde questo dettaglio sapendo automaticamente come eseguire il debug delle applet. Fino a quando non fanno lo stesso per i servlet, devi aiutare il tuo debugger facendo quanto segue:

  • Impostare il percorso di classe del debugger in modo che possa trovare sun.servlet.http.Http-Server e le classi associate.

  • Imposta il classpath del tuo debugger in modo che possa anche trovare i tuoi servlet e le classi di supporto, tipicamente server_root / servlet e server_root / classes.

Normalmente non vorresti server_root / servlets nel tuo classpath perché disabilita il ricaricamento del servlet. Questa inclusione, tuttavia, è utile per il debug. Consente al debugger di impostare i punti di interruzione in un servlet prima che il caricatore di servlet personalizzato in HttpServer carichi il servlet.

Dopo aver impostato il percorso di classe corretto, avviare il debug di sun.servlet.http.HttpServer. È possibile impostare i punti di interruzione in qualsiasi servlet a cui si desidera eseguire il debug, quindi utilizzare un browser Web per effettuare una richiesta a HttpServer per il servlet dato (http: // localhost: 8080 / servlet / ServletToDebug). Dovresti vedere l'esecuzione interrotta nei punti di interruzione.

Utilizzo dei commenti

I commenti nel codice possono aiutare il processo di debug in vari modi. I commenti possono essere utilizzati in molti altri modi nel processo di debug.

Il servlet utilizza commenti Java ed è possibile utilizzare commenti a riga singola (// ...) e a righe multiple (/ * ... * /) per rimuovere temporaneamente parti del codice Java. Se il bug scompare, dai un'occhiata più da vicino al codice che hai appena commentato e scopri il problema.

Intestazioni client e server

A volte, quando un servlet non si comporta come previsto, è utile esaminare la richiesta e la risposta HTTP non elaborate. Se hai familiarità con la struttura di HTTP, puoi leggere la richiesta e la risposta e vedere esattamente cosa sta succedendo esattamente con quelle intestazioni.

Suggerimenti importanti per il debug

Ecco un elenco di altri suggerimenti per il debug sul debug dei servlet:

  • Ricorda che server_root / classes non si ricarica e che server_root / servlets probabilmente lo fa.

  • Chiedi a un browser di mostrare il contenuto grezzo della pagina che sta visualizzando. Questo può aiutare a identificare i problemi di formattazione. Di solito è un'opzione nel menu Visualizza.

  • Assicurati che il browser non memorizzi nella cache l'output di una richiesta precedente forzando un ricaricamento completo della pagina. Con Netscape Navigator, usa Shift-Reload; con Internet Explorer usa Shift-Refresh.

  • Verifica che il metodo init () del tuo servlet accetti un parametro ServletConfig e chiami subito super.init (config).

Prima di procedere, lasciatemi spiegare tre termini importanti:

  • Internationalization (i18n) - Ciò significa consentire a un sito web di fornire diverse versioni di contenuti tradotti nella lingua o nazionalità del visitatore

  • Localization (l10n) - Ciò significa aggiungere risorse a un sito web per adattarsi a una particolare regione geografica o culturale.

  • locale- Questa è una particolare regione culturale o geografica. Di solito viene indicato come un simbolo della lingua seguito da un simbolo del paese che è separato da un trattino basso. Ad esempio "en_US" rappresenta la lingua inglese per gli Stati Uniti.

Ci sono un certo numero di elementi che dovrebbero essere presi cura durante la creazione di un sito Web globale. Questo tutorial non ti darebbe dettagli completi su questo, ma ti darebbe un buon esempio di come puoi offrire la tua pagina web in diverse lingue alla comunità di Internet differenziando la loro posizione, cioè locale.

Un servlet può prelevare la versione appropriata del sito in base alle impostazioni locali del richiedente e fornire la versione appropriata del sito in base alla lingua, alla cultura e ai requisiti locali. Di seguito è riportato il metodo dell'oggetto richiesta che restituisce l'oggetto Locale.

java.util.Locale request.getLocale()

Rilevamento delle impostazioni locali

Di seguito sono riportati gli importanti metodi locali che è possibile utilizzare per rilevare la posizione, la lingua e, naturalmente, la locale del richiedente. Tutti i metodi seguenti visualizzano il nome del paese e il nome della lingua impostati nel browser del richiedente.

Sr.No. Metodo e descrizione
1

String getCountry()

Questo metodo restituisce il codice del paese / regione in lettere maiuscole per questa lingua nel formato ISO 3166 a 2 lettere.

2

String getDisplayCountry()

Questo metodo restituisce un nome per il paese della locale che è appropriato per la visualizzazione all'utente.

3

String getLanguage()

Questo metodo restituisce il codice della lingua in minuscolo per questa locale nel formato ISO 639.

4

String getDisplayLanguage()

Questo metodo restituisce un nome per la lingua della locale appropriata per la visualizzazione all'utente.

5

String getISO3Country()

Questo metodo restituisce un'abbreviazione di tre lettere per il paese di questa lingua.

6

String getISO3Language()

Questo metodo restituisce un'abbreviazione di tre lettere per la lingua di questa locale.

Esempio

Questo esempio mostra come visualizzare una lingua e un paese associato per una richiesta:

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

public class GetLocale extends HttpServlet {

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
   
      //Get the client's Locale
      Locale locale = request.getLocale();
      String language = locale.getLanguage();
      String country = locale.getCountry();

      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();

      String title = "Detecting Locale";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + language + "</h1>\n" +
               "<h2 align = \"center\">" + country + "</h2>\n" +
         "</body>
         </html>"
      );
   }
}

Impostazione delle lingue

Un servlet può produrre una pagina scritta in una lingua dell'Europa occidentale come inglese, spagnolo, tedesco, francese, italiano, olandese ecc. Qui è importante impostare l'intestazione ContentLanguage per visualizzare correttamente tutti i caratteri.

Il secondo punto è visualizzare tutti i caratteri speciali utilizzando entità HTML, ad esempio "& # 241;" rappresenta "ñ" e "& # 161;" rappresenta "¡" come segue:

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

public class DisplaySpanish extends HttpServlet {

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

      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();

      // Set spanish language code.
      response.setHeader("Content-Language", "es");

      String title = "En Espa&ntilde;ol";
      String docType =
      "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1>" + "En Espa&ntilde;ol:" + "</h1>\n" +
               "<h1>" + "&iexcl;Hola Mundo!" + "</h1>\n" +
            "</body>
         </html>"
      );
   }
}

Date specifiche locali

È possibile utilizzare la classe java.text.DateFormat e il suo metodo statico getDateTimeInstance () per formattare la data e l'ora specifiche della locale. Di seguito è riportato l'esempio che mostra come formattare le date specifiche per una data locale:

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.DateFormat;
import java.util.Date;

public class DateLocale extends HttpServlet {

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      
      //Get the client's Locale
      Locale locale = request.getLocale( );
      String date = DateFormat.getDateTimeInstance(DateFormat.FULL, 
         DateFormat.SHORT, locale).format(new Date( ));

      String title = "Locale Specific Dates";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
     
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + date + "</h1>\n" +
            "</body>
         </html>"
      );
   }
}

Valuta specifica locale

È possibile utilizzare la classe java.txt.NumberFormat e il suo metodo getCurrencyInstance () statico per formattare un numero, come un tipo long o double, in una valuta specifica della locale. Di seguito è riportato l'esempio che mostra come formattare la valuta specifica per una data locale:

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;

public class CurrencyLocale extends HttpServlet {
    
   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();

      //Get the client's Locale
      Locale locale = request.getLocale( );
      NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
      String formattedCurr = nft.format(1000000);

      String title = "Locale Specific Currency";
      String docType =
         "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + formattedCurr + "</h1>\n" +
            "</body>
         </html>"
      );
   }
}

Percentuale specifica locale

È possibile utilizzare la classe java.txt.NumberFormat e il suo metodo statico getPercentInstance () per ottenere una percentuale specifica della locale. Di seguito è riportato l'esempio che mostra come formattare la percentuale specifica per una data locale:

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;

public class PercentageLocale extends HttpServlet {

   public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      
      // Set response content type
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      
      //Get the client's Locale
      Locale locale = request.getLocale( );
      NumberFormat nft = NumberFormat.getPercentInstance(locale);
      String formattedPerc = nft.format(0.51);

      String title = "Locale Specific Percentage";
      String docType =
      "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
      
      out.println(docType +
         "<html>\n" +
            "<head><title>" + title + "</title></head>\n" +
            "<body bgcolor = \"#f0f0f0\">\n" +
               "<h1 align = \"center\">" + formattedPerc + "</h1>\n" +
            "</body>
         </html>"
      );
   }
}

Finora, hai imparato come Servlet utilizza il descrittore di distribuzione (file web.xml) per distribuire la tua applicazione in un server web. Servlet API 3.0 ha introdotto un nuovo pacchetto chiamato javax.servlet.annotation. Fornisce tipi di annotazione che possono essere utilizzati per annotare una classe servlet. Se si utilizza l'annotazione, il descrittore di distribuzione (web.xml) non è richiesto. Ma dovresti usare tomcat7 o qualsiasi versione successiva di tomcat.

Le annotazioni possono sostituire la configurazione XML equivalente nel file descrittore di distribuzione web (web.xml) come la dichiarazione del servlet e la mappatura del servlet. I contenitori servlet elaboreranno le classi annotate al momento della distribuzione.

I tipi di annotazione introdotti in Servlet 3.0 sono:

Sr.No. Annotazione e descrizione
1

@WebServlet

Per dichiarare un servlet.

2

@WebInitParam

Per specificare un parametro di inizializzazione.

3

@WebFilter

Per dichiarare un filtro servlet.

4

@WebListener

Per dichiarare un WebListener

5

@HandlesTypes

Per dichiarare i tipi di classe che un ServletContainerInitializer può gestire.

6

@HttpConstraint

Questa annotazione viene utilizzata all'interno dell'annotazione ServletSecurity per rappresentare i vincoli di sicurezza da applicare a tutti i metodi del protocollo HTTP per i quali NON si verifica un elemento HttpMethodConstraint corrispondente all'interno dell'annotazione ServletSecurity.

7

@HttpMethodConstraint

Questa annotazione viene utilizzata all'interno dell'annotazione ServletSecurity per rappresentare i vincoli di sicurezza su messaggi di protocollo HTTP specifici.

8

@MultipartConfig

Annotazione che può essere specificata su una classe Servlet, che indica che le istanze del Servlet si aspettano richieste conformi al tipo MIME multipart / form-data.

9

@ServletSecurity

Questa annotazione viene utilizzata su una classe di implementazione Servlet per specificare i vincoli di sicurezza che devono essere applicati da un contenitore Servlet sui messaggi del protocollo HTTP.

Qui abbiamo discusso in dettaglio alcune delle annotazioni.

@WebServlet

The @WebServlet is used to declare the configuration of a Servlet with a container. The following table contains the list of attributes used for WebServlet annotation.

Sr.No. Attribute & Description
1

String name

Name of the Servlet

2

String[] value

Array of URL patterns

3

String[] urlPatterns

Array of URL patterns to which this Filter applies

4

Int loadOnStartup

The integer value gives you the startup ordering hint

5

WebInitParam[] initParams

Array of initialization parameters for this Servlet

6

Boolean asyncSupported

Asynchronous operation supported by this Servlet

7

String smallIcon

Small icon for this Servlet, if present

8

String largeIcon

Large icon for this Servlet, if present

9

String description

Description of this Servlet, if present

10

String displayName

Display name of this Servlet, if present

At least one URL pattern MUST be declared in either the value or urlPattern attribute of the annotation, but not both.

The value attribute is recommended for use when the URL pattern is the only attribute being set, otherwise the urlPattern attribute should be used.

Example

The following example describes how to use @WebServlet annotation. It is a simple servlet that displays the text Hello Servlet.

import java.io.IOException; 
import java.io.PrintWriter; 
import javax.servlet.ServletException; 
import javax.servlet.annotation.WebInitParam; 
import javax.servlet.annotation.WebServlet; 
import javax.servlet.http.HttpServlet; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 
@WebServlet(value = "/Simple") 
public class Simple extends HttpServlet {

   private static final long serialVersionUID = 1L; 

   protected void doGet(HttpServletRequest request, HttpServletResponse response)  
      throws ServletException, IOException { 
   
      response.setContentType("text/html");   
      PrintWriter out = response.getWriter();   
      out.print("<html><body>");   
      out.print("<h3>Hello Servlet</h3>");   
      out.print("</body></html>");         
   }   
}

Compile Simple.java in the usual way and put your class file in <Tomcat-installationdirectory>/webapps/ROOT/WEB-INF/classes.

Now try to call any servlet by just running http://localhost:8080/Simple. You will see the following output on the web page.

Hello servlet

@WebInitParam

The @WebInitParam annotation is used for specifying an initialization parameter for a Servlet or a Filter. It is used within a WebFilter or WebSevlet annotations. The following table contains the list of attributes used for WebInitParam annotation.

Sr.No. Attribute & Description
1

String name

Name of the initialization parameter

2

String value

Value of the initialization parameter

3

String description

Description of the initialization parameter

Example

The following example describes how to use @WeInitParam annotation along with @WebServlet annotation. It is a simple servlet that displays the text Hello Servlet and the string value Hello World! which are taken from the init parameters.

import java.io.IOException; 
import java.io.PrintWriter; 
import javax.servlet.ServletException; 
import javax.servlet.annotation.WebInitParam; 
import javax.servlet.annotation.WebServlet; 
import javax.servlet.http.HttpServlet; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse;

@WebServlet(value = "/Simple", initParams = { 
   @WebInitParam(name = "foo", value = "Hello "), 
   @WebInitParam(name = "bar", value = " World!") 
}) 
public class Simple extends HttpServlet {

   private static final long serialVersionUID = 1L; 

   protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {   
      
      response.setContentType("text/html");   
      PrintWriter out = response.getWriter();   
      out.print("<html><body>");   
      out.print("<h3>Hello Servlet</h3>");   
      out.println(getInitParameter("foo")); 
      out.println(getInitParameter("bar")); 
      out.print("</body></html>");         
   }   
}

Compile Simple.java in the usual way and put your class file in <Tomcat-installationdirectory>;/webapps/ROOT/WEB-INF/classes.

Now try to call any servlet by just running http://localhost:8080/Simple. You will see the following output on the web page.

Hello Servlet

Hello World!

@Webfilter

This is the annotation used to declare a servlet filter. It is processed by the container at deployment time, and the corresponding filter applied to the specified URL patterns, servlets, and dispatcher types.

The @WebFilter annotation defines a filter in a web application. This annotation is specified on a class and contains metadata about the filter being declared. The annotated filter must specify at least one URL pattern. The following table lists the attributes used for WebFilter annotation.

Sr.No. Attribute & Description
1

String filterName

Name of the filter

2

String[] urlPatterns

Provides array of values or urlPatterns to which the filter applies

3

DispatcherType[] dispatcherTypes

Specifies the types of dispatcher (Request/Response) to which the filter applies

4

String[] servletNames

Provides an array of servlet names

5

String displayName

Name of the filter

6

String description

Description of the filter

7

WebInitParam[] initParams

Array of initialization parameters for this filter

8

Boolean asyncSupported

Asynchronous operation supported by this filter

9

String smallIcon

Small icon for this filter, if present

10

String largeIcon

Large icon for this filter, if present

Example

The following example describes how to use @WebFilter annotation. It is a simple LogFilter that displays the value of Init-param test-param and the current time timestamp on the console. That means, the filter works like an interface layer between the request and the response. Here we use "/*" for urlPattern. It means, this filter is applicable for all the servlets.

import java.io.IOException; 
import javax.servlet.annotation.WebFilter; 
import javax.servlet.annotation.WebInitParam; 
import javax.servlet.*; 
import java.util.*;  

// Implements Filter class

@WebFilter(urlPatterns = {"/*"}, initParams = { 
   @WebInitParam(name = "test-param", value = "Initialization Paramter")}) 
public class LogFilter implements Filter {
   
   public void init(FilterConfig config) throws ServletException { 
      // Get init parameter  
      String testParam = config.getInitParameter("test-param");
            
      //Print the init parameter  
      System.out.println("Test Param: " + testParam);  
   } 

   public void doFilter(ServletRequest request, ServletResponse response,
      FilterChain chain) throws IOException, ServletException { 
	  
      // Log the current timestamp. 
      System.out.println("Time " + new Date().toString());  
         
      // Pass request back down the filter chain 
      chain.doFilter(request,response); 
   }

   public void destroy( ) {
      /* Called before the Filter instance is removed  
      from service by the web container*/ 
   } 
}

Compile Simple.java in the usual way and put your class file in <Tomcat-installationdirectory>/webapps/ROOT/WEB-INF/classes.

Now try to call any servlet by just running http://localhost:8080/Simple. You will see the following output on the web page.

Hello Servlet
  
Hello World!

Now, open the servlet console. There, you will find the value of the init parameter testparam and the current timestamp along with servlet notification messages.