Java Servlet è un programma lato server scritto nell'omonimo linguaggio di programmazione che riceve i segnali del client e gli invia le risposte. È un elemento costitutivo chiave nel tipico Java EE, oltre a JSP, EJB, XML e altre tecnologie correlate. L'applicazione può essere impacchettata in un file WAR (Web AR chive) per la distribuzione su un server web. Un server che può eseguire un servlet Java è chiamato container. Un programma che gira su un tale server può creare pagine web dinamiche.

Servlet Java: le basi

I contenitori più popolari e ampiamente utilizzati sono Tomcat e JBoss. Tecnicamente, una Servlet è una normale classe Java che ha un'estensione per il protocollo Common Client Server o HTTP. In pratica, viene utilizzato per elaborare le richieste tramite gli override HttpServlet GET e POST, rispettivamente. Il contenitore Java Servlet fornisce oggetti richiesta-risposta Http.ServletRequest e Http.ServletResponse. E di solito viene utilizzato insieme a JSP per generare contenuto dinamico.

Scenario modello tipico:

Il JSP presenta all'utente un modulo per inserire i dati.

Il servlet riceve l'input, lo elabora e invia una risposta.

Per un lavoro di qualità, utilizza filtri speciali.

I filtri Java Servlet sono plug-in Java utilizzati per intercettare ed elaborare le richieste prima che vengano inviate ai servlet e rispondono dopo il completamento del codice e prima che il contenitore invii una risposta al client.

Attività comuni eseguite con i filtri:

Registrazione dei parametri di query per la registrazione dei file.

Autenticazione e autorizzazione delle richieste di risorse.

Formattazione del corpo o dell'intestazione della richiesta prima di inviarlo al servlet.

Compressione dei dati di risposta inviati al client.

Modificando la risposta, aggiungendo alcuni cookie.

Informazioni sull'intestazione del servlet Java.

I filtri sono connessi e configurati nel file descrittore di distribuzione (web.xml). Servlet e filtri non si conoscono, quindi puoi aggiungere o rimuovere un filtro semplicemente modificando web.xml. È consentito disporre di più filtri per una risorsa, creare una catena di filtri per web.xml o eseguire filtri Java Servlet implementando l'interfaccia javax.servlet.Filter.

Le richieste parallele al server vengono elaborate dai thread, il che fornisce importanti qualità web: multithreading e concorrenza.

Funzioni principali:

Portabilità. Poiché Java è indipendente dalla piattaforma, lo stesso vale per i servlet. Ad esempio, puoi crearlo su un sistema operativo Windows in modo che gli sviluppatori GlassFish lo utilizzino come server Web e quindi possano eseguirlo su qualsiasi altro sistema operativo come Unix, Linux con server Web Apache Java Servlet. Questa caratteristica lo rende portatile e questo è il suo principale vantaggio rispetto alla CGI.

Efficienza e scalabilità. Una volta che il Servlet è stato distribuito e caricato sul server web, può iniziare immediatamente a eseguire le richieste del client. Viene chiamato da un thread leggero, quindi più richieste client possono essere popolate contemporaneamente utilizzando la funzione multithreading di Java. A differenza di CGI, dove il server avvia un nuovo processo per ogni richiesta del client.

Affidabilità. Ereditando le principali funzionalità Java come la raccolta dei rifiuti, la gestione delle eccezioni, Java Security Manager e altre, è meno soggetto a problemi di gestione e perdite di memoria. Questo rende lo sviluppo dell'applicazione al suo interno sicuro e privo di errori.

La necessità di pagine web dinamiche

Ci sono molte ragioni per cui un'azienda vorrebbe creare pagine web dinamiche al volo, ad esempio quando i dati sul sito web cambiano frequentemente. I siti di notizie e meteo in genere si affidano alla CGI per mantenere i contenuti aggiornati senza richiedere l'attenzione costante degli sviluppatori. Le pagine web di e-commerce che elencano i prezzi correnti e i livelli delle scorte utilizzano la CGI per recuperare questi contenuti su richiesta dall'infrastruttura interna dell'azienda.

Molti utenti hanno esperienza nell'uso della tecnologia Java per creare servizi Web basati su CGI, ma i Java Servlet sono più efficienti, più potenti, più facili da usare e più economici delle tradizionali alternative CGI.

Vantaggi dei servlet Java:

Efficienza. Nella CGI tradizionale, ogni richiesta HTTP avvia un nuovo processo CGI. Anche se il suo codice è ben implementato, c'è spesso una quantità significativa di sovraccarico non solo quando si avvia un processo, ma anche durante la sua esecuzione. Quando vengono utilizzati i servlet, la JVM rimane caricata in memoria e ogni richiesta viene elaborata da un thread Java. Come esempio di Java Servlet, se ci sono X richieste simultanee nel modello CGI tradizionale, ciò significa che il codice per il programma viene caricato in memoria X volte. Questo diventa un carico eccessivo sul server web. Tuttavia, in un ambiente servlet, esistono X thread in cui viene eseguita solo una copia della sua classe. Ciò si traduce in una maggiore efficienza e scalabilità su più piattaforme.

Convenienza. Quando si utilizza il programma, non ha senso imparare un nuovo linguaggio come Perl solo per eseguire funzioni CGI. Inoltre, i servlet dispongono di un'infrastruttura estesa per molte attività relative all'HTML, che accelera notevolmente il processo di sviluppo.

Potenza - Sfortunatamente, gli script CGI tradizionali lasciano molto a desiderare. Ad esempio, i loro normali programmi non possono parlare direttamente con i server web, il che significa che l'intera interfaccia deve essere creata. Le servlet possono comunicare direttamente con i server Web, semplificando le operazioni che richiedono l'accesso diretto ai datastore. Sono inoltre unici perché possono comunicare con altri servlet e mantenere le informazioni tra le richieste, rendendo estremamente facile il monitoraggio della sessione.

La portabilità di Java si estende direttamente ai servlet. In effetti, quasi tutti i server Web principali attualmente in uso supportano Java Servlet direttamente o tramite un plug-in.

Economia. Dal punto di vista dello sviluppo, l'implementazione dei servlet è molto più economica rispetto ad altre opzioni che richiedono una codifica personalizzata per interagire correttamente con i server web. Il reindirizzamento Java Servlet è pronto per l'uso e può mantenere il valore aziendale il più basso possibile senza sacrificare i vantaggi del contenuto dinamico.

Una delle caratteristiche più belle di Java è la sua natura multiforme. Ovviamente, creare app desktop e persino mobili tradizionali è fantastico. Ma cosa succede se si vuole uscire dai sentieri battuti ed entrare nel territorio dello sviluppo di applicazioni web in Java? La buona notizia per te è che il linguaggio viene fornito con un'API Servlet completa che ti consente di creare applicazioni Web robuste senza troppi problemi.

Scrivere applicazioni Java con le servlet

Quindi, abbiamo già creato i file di configurazione per l'applicazione. Tuttavia, nel suo stato attuale, non fa letteralmente nulla. Vogliamo che i clienti siano in grado di registrarsi utilizzando un modulo HTML, quindi la prossima cosa che dobbiamo fare è creare file JSP che visualizzeranno il modulo sopra e i dettagli del cliente dopo che la registrazione è andata a buon fine. Questo è quello che faremo ora.

Stiamo lavorando sull'aspetto

L'aspetto dell'applicazione sarà determinato da due file JSP: nel contesto di MVC, questi sono chiamati viste. Il primo sarà responsabile della visualizzazione del modulo di registrazione e degli eventuali errori causati dopo la verifica dei dati inseriti. La seconda sarà una normale pagina di benvenuto, che mostrerà i dati inseriti dal cliente al completamento con successo del processo di registrazione.

Ecco il primo file JSP:

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

registrazione

$ (violazione).

Nome: Cognome: E-mail:

Il file contiene HTML semplice con un paio di extra. Eccola, la bellezza di JSP combinata con JSTL e JEL. Nota quanto è facile controllare gli errori di convalida utilizzando tag standard come<с:if>e .

L'attributo action del modulo di registrazione punta al seguente URL: $ (pageContext.request.contextPath) / processcustomer. Ciò significa che ogni volta che un cliente tenta di registrarsi, i dati verranno inviati al processcustomer indipendentemente dall'URL in cui è disponibile il modulo. Ciò si ottiene tramite la funzionalità degli oggetti disponibili dal file JSP, come request.

Vedremo presto come il servlet si lega all'URL processcustomer e come interagisce con l'input. Per ora, diamo un'occhiata al file JSP che è responsabile della pagina di benvenuto:

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

Grazie per la registrazione!

I tuoi dati inseriti:

Nome:$ (nome)

Cognome:$ (cognome)

E-mail:$ (e-mail)

Ora che abbiamo capito come vengono visualizzate le pagine, il passo successivo è creare un servlet responsabile della raccolta dei dati del client dalle richieste POST e della convalida dei dati in modo semplice.

Scrivere un controller

Scrivere un servlet in grado di recuperare i dati da un modulo di registrazione è facile come sgusciare le pere. Tutto ciò che dobbiamo fare è scrivere una sottoclasse per la classe HttpServlet e implementare i suoi metodi doGet() o doPost() (o entrambi, se necessario). In questo caso, il servlet interagirà con i dati provenienti dalle richieste POST.

Ecco come appare:

@WebServlet (name = "CustomerController", urlPatterns = "/ processcustomer") public class CustomerController estende HttpServlet (@Override protected void doPost (richiesta HttpServletRequest, risposta HttpServletResponse) genera ServletException, IOestException (customerRequest) .setAsrequest = violazione customer.validate (); if (! violazioni.isEmpty ()) (request.setAttribute ("violazioni", violazioni);) String url = determineUrl (violazioni); request.getRequestDispatcher (url ) .forward (richiesta, risposta); ) private String determineUrl (Elenco violazioni) (if (! violazioni.isEmpty ()) (return "/";) else (return "/WEB-INF/views/customerinfo.jsp"; )) private static class RequestCustomer (private final String firstName; private final String lastName; private final String email; private RequestCustomer (String firstName, String lastName, String email) (this.firstName = firstName; th is.lastName = lastName; this.email = email; ) public static RequestCustomer fromRequestParameters (HttpServletRequest request) (restituisce un nuovo RequestCustomer (request.getParameter ("firstname"), request.getParameter ("lastname"), request.getParameter ("email"));) public void setAsRequest requestAttributes (HttpServletRequest ( request.setAttribute ("firstname", firstName); request.setAttribute ("lastname", lastName); request.setAttribute ("email", email);) public List validate () (List violazioni = new ArrayList<>(); if (! StringValidator.validate (firstName)) (violations.add ("Il nome è un campo obbligatorio");) if (! StringValidator.validate (lastName)) (violations.add ("Il cognome è un campo obbligatorio") ;) if ( ! EmailValidator.validate (email)) (violations.add ("L'email deve essere ben formata");) return violazioni; )))

La prima cosa da notare qui è l'uso dell'annotazione @WebServlet (name = "CustomerController", urlPatterns = "/ processcustomer"). Indica al contenitore servlet di utilizzare la classe CustomerController per gestire le richieste HTTP su / processcustomer. Lo stesso effetto può essere ottenuto aggiungendo direttive di mappatura servlet a web.xml come, ma poiché stiamo usando Servlet Specification 3.1 non abbiamo bisogno di ricorrere a questo metodo.

Qui abbiamo chiamato il servlet CustomerController perché è buona norma utilizzare il nome della classe servlet come valore dell'attributo name dell'annotazione @WebServlet. In caso contrario, alcuni contenitori non corrisponderanno, generando un errore 404.

La classe CustomerController stessa esegue alcune semplici attività. Innanzitutto, raccoglie i dati inseriti nel modulo utilizzando l'implementazione dell'interfaccia HttpServletRequest, che contiene i valori corrispondenti ai campi nome, cognome e email del modulo. Quindi imposta questi valori come attributi di richiesta in modo che possano essere nuovamente visualizzati sul modulo o sulla pagina dei risultati. Infine, i validatori controllano la validità dei dati inseriti.

I validatori sono classi semplici che controllano determinate proprietà, ad esempio se una stringa è vuota e se un'e-mail ha l'aspetto di un'e-mail. Sul GitLab dell'autore, puoi guardare la loro implementazione.

L'esito della convalida influisce sull'ulteriore corso degli eventi: se i dati non sono validi, il client viene reindirizzato tramite l'oggetto RequestDispatcher alla pagina di registrazione, dove vengono visualizzati gli errori corrispondenti. Se tutto è in ordine, viene visualizzata la pagina di benvenuto.

Quindi, abbiamo creato un'intera applicazione Web Java che consente di registrare i client utilizzando un modulo HTML, un servlet di base e alcuni JSP. È ora di iniziarlo.

Avvio dell'applicazione

Per avviare l'applicazione, è necessario eseguire i seguenti passaggi:

IntelliJ IDEA). Quando si distribuisce il progetto e lo si esegue, il browser predefinito dovrebbe iniziare con una finestra di registrazione.

Prova a compilare non tutti i campi del modulo o non compilarli affatto e vedrai come vengono visualizzati gli errori sopra i campi corrispondenti. Inserisci tutto come previsto e verrai reindirizzato alla pagina di benvenuto.

Conclusione

Quindi hai tutte le competenze necessarie per creare la tua applicazione web Java senza dover ricorrere a framework complessi. Tutto ciò di cui hai bisogno è un'API Servlet, una tecnologia come JSP per il rendering e Java integrato. Fantastico, vero?

Vale la pena notare che l'implementazione della classe CustomerController mette in evidenza pregi e difetti dei servlet: da un lato, mostra brevemente quanto sia facile elaborare i parametri di richiesta e inviare risposte al client in diversi formati. Ma questa funzionalità ha un prezzo: entrambe le implementazioni delle interfacce HttpServletResponse e HttpServletResponse sono normali localizzatori di servizi. Questo non vuol dire che questa sia una cosa negativa, poiché i localizzatori contengono semplicemente dati. Tieni presente, tuttavia, che queste implementazioni si legheranno sempre a un servlet.

I servlet sono programmi Java eseguiti sul lato server di un'applicazione Web. Proprio come le applet estendono dinamicamente le funzionalità di un browser Web, i servlet estendono dinamicamente le funzionalità di un server Web. Sebbene i servlet possano servire qualsiasi richiesta, sono comunemente usati per estendere i server web. Per tali applicazioni, la tecnologia Java Servlet definisce classi servlet specifiche per HTTP. I pacchetti javax.servlet e javax.servlet.http forniscono interfacce e classi per la creazione di servlet.

Qual è la struttura di un progetto web?

Che cos'è un contenitore servlet? Ciclo di vita servlet.

Un contenitore servlet è un programma che gestisce il ciclo di vita dei servlet.
Ciclo di vita servlet: è gestito dal contenitore servlet, la prima volta che si accede al servlet, viene caricato in memoria e viene chiamato il metodo init(). In tutta l'applicazione, viene chiamato il metodo service() per gestire le richieste del client. Quando l'applicazione termina, viene chiamato il metodo destroy() e il servlet viene scaricato dalla memoria.

Quali sono i compiti, le funzionalità del contenitore servlet?

Un contenitore servlet può fungere da server Web autonomo completo, fornire pagine per un altro server Web come Apache o integrarsi in un server di applicazioni Java EE. Fornisce lo scambio di dati tra il servlet e i client, si occupa di funzioni come la creazione di un ambiente software per un servlet funzionante, l'identificazione e l'autorizzazione dei client, l'organizzazione di una sessione per ciascuno di essi.

In che modo sendRedirect() è diverso da forward()?

Il metodo forward() viene utilizzato per chiamare il JSP utilizzando un percorso relativo e il metodo sendRedirect() viene utilizzato per fare riferimento al JSP utilizzando un percorso assoluto. La differenza tra questi metodi è che un oggetto di richiesta esistente viene passato con il metodo forward() e viene generata una nuova richiesta quando viene chiamato il metodo sendRedirect(). In quest'ultimo caso, le informazioni dovrebbero essere trasferite con altri oggetti. Inoltre, il metodo forward() è più veloce.

Cosa sai dei filtri servlet?

L'implementazione dell'interfaccia Filtro consente di creare un oggetto che intercetta la richiesta, può trasformare l'intestazione e il contenuto della richiesta del cliente. I filtri non creano una richiesta o una risposta, li modificano solo. Il filtro preelabora la richiesta prima che entri nel servlet e quindi (se necessario) elabora la risposta proveniente dal servlet. Il filtro può interagire con diversi tipi di risorse, in particolare con servlet e pagine JSP. I filtri servlet possono:

intercettare l'avvio della servlet prima che venga avviata la servlet.
determinare il contenuto della richiesta prima dell'avvio del servlet.
modificare le intestazioni della richiesta e i dati in cui è compressa la richiesta in entrata.
modificare le intestazioni della risposta e i dati in cui è compressa la risposta ricevuta.
intercettare l'avvio di un servlet dopo una chiamata al servlet.

Un filtro servlet può essere configurato per funzionare con un singolo servlet o un gruppo di servlet. La base per la generazione dei filtri è l'interfaccia javax.servlet.Filter, che implementa tre metodi:

void init (config FilterConfig) genera ServletException;
vuoto distruggere ();
void doFilter (richiesta ServletRequest, risposta ServletResponse, catena FilterChain) genera IOException, ServletException;

Il metodo init() viene chiamato prima dell'avvio del filtro e imposta l'oggetto di configurazione del filtro. Il metodo doFilter esegue il lavoro effettivo del filtro. Pertanto, il server chiama init() una volta per avviare il filtro, quindi chiama doFilter() tante volte quante saranno le richieste inviate direttamente a questo filtro. Dopo che il filtro ha terminato il suo lavoro, viene chiamato il metodo destroy().

Perché hai bisogno di ascoltatori in servlet?

I listener di contesto e sessione sono classi che possono tenere traccia di quando un contesto o una sessione è stato inizializzato, o tenere traccia di quando dovrebbero essere distrutti e quando gli attributi sono stati aggiunti o rimossi dal contesto o dalla sessione. Servlet 2.4 estende il modello del listener di richieste consentendo di tenere traccia di come una richiesta viene creata e distrutta e come gli attributi vengono aggiunti e rimossi dal servlet. Le seguenti classi sono state aggiunte in Servlet 2.4:

ServletRequestListener
ServletRequestEvent
ServletRequestAttributeListener
ServletRequestAttributeEvent

Come gestisco le eccezioni generate da un altro servlet nell'applicazione?

Poiché il browser comprende solo HTML, quando l'applicazione genera un'eccezione, il contenitore servlet gestirà l'eccezione e genererà una risposta HTML. Questo è simile a ciò che accade con codici di errore come 404, 403, ecc. L'API Servlet fornisce supporto per i nostri servlet per la gestione di eccezioni ed errori, che possiamo specificare nel descrittore di distribuzione. Il compito principale di tali servlet è gestire l'errore o l'eccezione e inviare una risposta HTML chiara all'utente. Ad esempio, puoi fornire un collegamento alla pagina principale, nonché una descrizione di alcuni dettagli sull'errore.

Che cos'è un descrittore di distribuzione?

Il descrittore di distribuzione è un file di configurazione dell'elemento che verrà distribuito nel contenitore servlet. Nella specifica Java Platform, Enterprise Edition, un descrittore di distribuzione descrive come deve essere distribuito un componente, modulo o applicazione (come un'applicazione Web o aziendale).

Questo file di configurazione specifica le opzioni di distribuzione per un modulo o un'applicazione con impostazioni e opzioni di sicurezza specifiche e descrive i requisiti di configurazione specifici. La sintassi per i file dei descrittori di distribuzione è XML.

Come si implementa l'avvio di un servlet con l'avvio di un'applicazione?

Il contenitore servlet di solito carica il servlet alla prima richiesta del client, ma a volte è necessario caricare il servlet all'inizio dell'applicazione (ad esempio, se il servlet è ingombrante e richiederà molto tempo per caricarsi). Per fare ciò, è necessario utilizzare l'elemento load-on-startup nel descrittore (o l'annotazione loadOnStartup), che indicherà se il servlet deve essere caricato all'avvio.

Il valore deve essere int. Se il valore è negativo, il servlet verrà caricato su richiesta del client e se 0 e oltre, verrà caricato all'avvio dell'applicazione. Più basso è il numero, prima il servlet sarà nella coda di download.

Che cos'è l'oggetto ServletConfig?

L'interfaccia javax.servlet.ServletConfig viene utilizzata per passare le informazioni di configurazione a un servlet. Ogni servlet ha il proprio oggetto ServletConfig, che viene istanziato dal contenitore servlet. I parametri init in web.xml (o annotazioni WebInitParam) vengono utilizzati per impostare i parametri di configurazione. Il metodo getServletConfig() viene utilizzato per ottenere l'oggetto ServletConfig per questo servlet.

Che cos'è l'oggetto ServletContext?

L'interfaccia javax.servlet.ServletContext definisce un numero di metodi che un servlet utilizza per comunicare con il suo contenitore servlet, come ottenere il tipo MIME di un file, inviare richieste o scrivere su un file di log. L'oggetto ServletContext è univoco e disponibile per tutti i servlet in un'applicazione web. Possiamo utilizzare l'oggetto ServletContext quando dobbiamo fornire l'accesso a uno o più servlet ai parametri inizializzati dell'applicazione web. Per farlo, usa l'elemento in web.xml. L'oggetto ServletContext può essere ottenuto utilizzando il metodo getServletContext() dell'interfaccia ServletConfig.

I contenitori servlet possono anche fornire oggetti di contesto univoci per un gruppo di servlet. Ciascuno dei gruppi sarà associato a un diverso insieme di URL di percorso host.

ServletContext è stato esteso nella specifica Servlet 3 e fornisce l'aggiunta programmatica di listener e filtri alla tua applicazione. Questa interfaccia ha anche molti metodi utili come getMimeType (), getResourceAsStream (), ecc.

Qual è la differenza tra ServletContext e ServletConfig?

Di seguito sono riportate alcune delle differenze:

ServletConfig è un oggetto univoco per ogni servlet, mentre ServletContext è univoco per l'intera applicazione.
ServletConfig viene utilizzato per fornire parametri di inizializzazione al servlet e ServletContext viene utilizzato per fornire parametri di inizializzazione dell'applicazione per tutti i servlet.
Non abbiamo la possibilità di impostare attributi sull'oggetto ServletConfig, mentre possiamo impostare attributi sull'oggetto ServletContext che saranno disponibili per altri servlet.

Interfaccia ServletResponse.

L'interfaccia ServletResponse è uno strumento per l'invio di dati al client. Tutti i metodi di questo strumento servono esattamente a questo scopo.

Interfaccia ServletRequest.

L'interfaccia ServletRequest è uno strumento per ottenere i parametri di richiesta HTTP. Questa interfaccia ha alcuni metodi identici nel nome e nello scopo a ServletContext.

Che cos'è l'inviatore di richieste?

L'interfaccia RequestDispatcher viene utilizzata per passare una richiesta a un'altra risorsa (potrebbe essere HTML, JSP o un altro servlet nella stessa applicazione). Possiamo usarlo per aggiungere contenuto da un'altra risorsa alla risposta. Questa interfaccia viene utilizzata per la comunicazione interna tra servlet nello stesso contesto. Ci sono due metodi implementati nell'interfaccia:

void forward (ServletRequest var1, ServletResponse var2) - inoltra una richiesta dal servlet a un'altra risorsa (servlet, file JSP o HTML) sul server.
void include (ServletRequest var1, ServletResponse var2) - Include il contenuto della risorsa (servlet, JSP o pagina HTML) in risposta.

È possibile accedere all'interfaccia utilizzando il metodo ServletContext getRequestDispatcher (String s). Il percorso deve iniziare con una /, che verrà interpretata come relativa al percorso radice corrente del contesto.

Come si può creare un deadlock in un servlet?

È possibile ottenere un deadlock implementando una chiamata al metodo in loop, ad esempio chiamando il metodo doPost() nel metodo doGet() e chiamando doGet() nel metodo doPost().

Come ottengo l'indirizzo della servlet sul server?

Per ottenere il percorso effettivo della servlet sul server, è possibile utilizzare questa costruzione: getServletContext().GetRealPath (request.getServletPath()).

Come ottengo le informazioni sul server da un servlet?

Le informazioni sul server possono essere ottenute utilizzando l'oggetto ServletContext utilizzando il metodo getServerInfo(). Quelli. getServletContext().getServerInfo().

Come ottenere l'indirizzo IP del client sul server?

Utilizzare request.getRemoteAddr() per ottenere l'ip del client nel servlet.

Cosa sai delle classi wrapper servlet?

L'API Servlet HTTP fornisce due classi wrapper: HttpServletRequestWrapper e HttpServletResponseWrapper. Aiutano gli sviluppatori a implementare le proprie implementazioni della richiesta servlet e dei tipi di risposta. Possiamo estendere queste classi e sovrascrivere solo i metodi necessari per implementare i nostri tipi di oggetto di risposta e richiesta. Queste classi non vengono utilizzate nella programmazione servlet standard.

Cosa sono i servlet? I servlet sono, infatti, moduli di elaborazione delle richieste HTTP e FTP utilizzati per costruire porte web.

La base di questi portali è il server WEB stesso, un programma che contiene il socket del server, riceve e trasmette dati. Molto spesso, per accelerare il lavoro, il server non è scritto in Java, ma in qualche altro linguaggio di programmazione (ad esempio, in C ++).

Un servlet di base funziona insieme al server. È a lui che il server invia i dati e da lui riceve la risposta inviata al client. In effetti, il servlet sottostante è il "cervello" del server. La funzione principale di questo servlet è leggere la richiesta del client, decrittografarla e, in accordo con la decrittazione, trasferire il lavoro al servlet responsabile di questo tipo di informazioni richieste. Spesso il server stesso svolge il ruolo del servlet sottostante per raggiungere la velocità. Questo è esattamente il modo in cui funziona Jacarta Tomcat.

La figura mostra un diagramma del trasferimento di chiamate (richieste) e risposte (risposte) tra il server e i servlet. Questo diagramma illustra il funzionamento di un server HTTP che ha diverse pagine JSP e due risorse "/ sample1" e "/ sample2", che vengono elaborate da due servlet - "Sample1 Servlet" e "Sample2 Servlet", rispettivamente.

Analizziamo passo passo quanto mostrato in figura:

il client si connette al server
il server passa la richiesta al "servlet di base"
il servlet di base estrae l'URI della risorsa dalla richiesta
- se l'URI punta a "/ sample1" allora la richiesta interamente(invariato) viene passato al servlet "Sample1 Servlet", che elabora ulteriormente questa richiesta
- se l'URI punta a "/ sample2", il server passa la richiesta al "Sample2 Servlet"
- in tutti gli altri casi, la richiesta viene passata al modulo "JSP Servlet"
il servlet a cui è stato assegnato il controllo elabora i dati, crea una risposta e quindi la risposta viene rimandata al servlet sottostante.
la servlet di base, senza elaborare i dati ricevuti, li rimanda immediatamente al server
il server invia i dati al client

Pertanto, il compito di elaborare una richiesta è suddiviso in parti logiche, per ciascuna delle quali è responsabile un modulo separato, un proprio "mattone software". In effetti, ci possono essere molti più passaggi nell'elaborazione di una richiesta. Ad esempio, moduli diversi possono essere responsabili dei metodi "GET" e "POST".

Interfaccia servlet

Ciò che tutti questi moduli hanno in comune è che sono interconnessi end-to-end utilizzando l'interfaccia javax.servlet.Servlet

Diamo un'occhiata a questa interfaccia. Elenca solo 5 metodi:

Public void init (configurazione ServletConfig) genera ServletException Questo metodo viene chiamato per informare il servlet che è incluso come modulo per servire le richieste del client. Il parametro config separa l'interfaccia javax.servlet.ServletConfig, che contiene informazioni sull'ambiente del server, il nome del servlet, i parametri iniziali e altri vantaggi. L'interfaccia javax.servlet.ServletConfig sarà discussa un po' più avanti. Si presume che dopo aver chiamato questa funzione, il servlet salverà ordinatamente questa configurazione nella sua variabile e la emetterà utilizzando un altro metodo: public ServletConfig getServletConfig () Dopo aver ricevuto le informazioni di sistema utilizzando "getServletConfig ()", il server potrebbe voler scoprire il nome dell'autore, la data di creazione, altre informazioni sul servlet, che si ottengono chiamando public String getServletInfo ()

Per elaborare la richiesta e ottenere il risultato della sua elaborazione, utilizzare la funzione

Il servizio public void (richiesta ServletRequest, risposta ServletResponse) genera ServletException, java.io.IOException In questa funzione vengono passati due strumenti al codice che elaborerà i dati: uno per ricevere i dati dal server e l'altro per inviare il risultato del servlet. Di conseguenza, questi sono i parametri di richiesta e risposta che separano le interfacce javax.servlet.ServletRequest e javax.servlet.ServletResponse.Tutto il lavoro con i dati viene eseguito proprio attraverso queste interfacce, quindi ne parleremo più dettagliatamente di seguito.

Dopo che il server non ha più bisogno di questo modulo, viene chiamato il metodo

Public void destroy() che completa tutte le operazioni con l'oggetto servlet.

Interfaccia ServletConfig

I 4 metodi autoesplicativi sono l'essenza dell'interfaccia javax.servlet.ServletConfig:

Public String getServletName () public ServletContext getServletContext () public String getInitParameter (String name) public java.util.Enumeration getInitParameterNames ()

Penso che lo scopo di tutte le funzioni sia chiaro, tranne

Public ServletContext getServletContext() Questo metodo restituisce un collegamento a uno strumento server molto utile:

Interfaccia ServletContext

ServletContext è un'interfaccia che definisce l'accesso alle seguenti funzioni molto utili:

Oggetto pubblico getAttribute (nome stringa) public java.util.Enumeration getAttributeNames () public void setAttribute (nome stringa, oggetto oggetto) public void removeAttribute (nome stringa) Quattro metodi per lavorare con gli attributi. Il ruolo degli attributi è svolto da qualsiasi oggetto di qualsiasi classe. Lo scopo di queste funzioni è trasferire oggetti diversi tra servlet non correlati. public String getInitParameter (nome stringa) public java.util.Enumeration getInitParameterNames () Accesso ai parametri con cui è stato avviato il server. Potrebbero esserci anche un nome host, una porta e altre cose utili. public int getMajorVersion () public int getMinorVersion () Restituisce le versioni dell'API Servlet. public String getMimeType (file String) Restituisce il tipo MIME associato al file specificato nella variabile file. Ricorda come hai dovuto definire MIME in SimpleWEBServer e apprezza la comodità! public java.util.Set getResourcePaths () public java.net.URL getResource (percorso stringa) genera java.net.MalformedURLException public InputStream getResourceAsStream (percorso stringa) Restituisce i percorsi alle risorse disponibili per il server e le risorse stesse come URL e flussi di dati . public RequestDispatcher getRequestDispatcher (percorso) public RequestDispatcher getNamedDispatcher (nome) RequestDispatcher è uno strumento per inoltrare una richiesta a un'altra risorsa. Queste funzioni sono necessarie per ottenere l'oggetto di questo strumento per le risorse specificate. Cioè, ad esempio, per inoltrare una richiesta al servlet "sample1" dal corpo del servlet, puoi fare questo: getServletConfig (). GetServletContext (). GetNamedDispatcher ("sample1"). Forward (richiesta, risposta);

La stessa classe RequestDispatcher include solo due metodi:

Public void forward (richiesta ServletRequest, risposta ServletResponse) genera ServletException, java.io.IOException public void include (richiesta ServletRequest, risposta ServletResponse) genera ServletException, java.io.IOException Il primo è reindirizzare la richiesta e il secondo è includere il risultato del servlet chiamato al risultato di quello corrente. Ad esempio, servlet 1 stampa la parola "test 1", quindi chiama include per servlet due e quindi stampa la parola "test 2". Servlet 2 stampa solo la parola "e". Servlet 1 produrrà la stringa "test 1 e test 2". public void log (String msg) Scrive qualcosa nel log del server. public void log (String message, Throwable throwable) Definire un'eccezione e una frase che verranno registrate quando viene ricevuta questa eccezione. public String getRealPath (String path) Traduce un percorso come "/index.html" in "http: //host/contextPath/index.html" public String getServerInfo () Restituisce il nome del server. public ServletContext getContext (String uripath) Questo metodo consente di scambiare ServletContext tra diverse risorse dello stesso server. public String getServletContextName () Restituisce il nome del servlet a cui appartiene questo oggetto dell'interfaccia ServletContect.

Interfaccia ServletRequest

L'interfaccia ServletRequest è uno strumento per ottenere i parametri di richiesta HTTP. Questa interfaccia ha diversi metodi identici nel nome e nello scopo a ServletContext:

Public Object getAttribute (String name) public java.util.Enumeration getAttributeNames () public void setAttribute (String name, Object o) public void removeAttribute (java.lang.String name) public String getServerName () public RequestDispatcher getRequestDispatcher (String path)

I restanti metodi consentono di lavorare comodamente con l'intestazione della richiesta HTTP:

Public String getCharacterEncoding () public void setCharacterEncoding (String env) genera java.io.UnsupportedEncodingException Utilizzo della codifica dei caratteri nei campi di intestazione HTTP. Le funzioni impostano il metodo per decifrare le richieste CGI dal modulo %NN in caratteri ordinari. Ad esempio, quale standard - KOI8-R, windows-1251 o UTF-8 - dovrebbe essere usato per decifrare i caratteri cirillici. public int getContentLength () public String getContentType () Legge i campi "Content-Length", "Content-Type" dalla richiesta HTTP. public jString getParameter (String name) public java.util.Enumeration getParameterNames () public String getParameterValues (String name) public java.util.Map getParameterMap () Funzioni per ottenere un campo dall'intestazione HTTP e il suo valore. public ServletInputStream getInputStream () genera java.io.IOException public java.io.BufferedReader getReader () genera java.io.IOException Recupera il flusso di dati in ingresso o il suo "lettore". Reader viene utilizzato per leggere le informazioni di testo: decrittograferà automaticamente le stringhe in base al set di caratteri specificato. Attenzione! C'è un bug significativo in J2EE 1.3: durante la decrittografia del carattere % 25 (il carattere % nelle richieste Post e Get), Reader restituisce un errore (il bug è stato rilevato sui server Tomcat 4 e Resign). È possibile che esista un bug simile con altri simboli. public String getProtocol() Recupera la versione HTTP del protocollo di richiesta (ad esempio, "HTTP/1.1"). public String getScheme() Restituisce il nome dello schema della richiesta. Ad esempio "http", "https" o "ftp". public int getServerPort () public String getRemoteAddr () public String getRemoteHost () public boolean isSecure () Porta del server, IP del client, nome host del client e se la connessione è privata (HTTPS) public java.util.Locale getLocale () public java.util .Enumerazione getLocales () La lingua del documento preferita dal cliente (risultato dell'elaborazione del campo "Accetta-Lingua")

Interfaccia ServletResponse

L'interfaccia ServletResponse è uno strumento per l'invio di dati al client. Tutti i metodi di questo strumento servono esattamente a questo scopo:

Public java.lang.String getCharacterEncoding () public void setLocale (java.util.Locale loc) public java.util.Locale getLocale () Il primo metodo restituisce il tipo di codifica MIME (ad esempio, UTF8), in cui verranno visualizzato. I secondi due metodi funzionano anche con charset. Indicano la lingua utilizzata nel documento (ad esempio - russo). public ServletOutputStream getOutputStream() genera java.io.IOException Restituisce il flusso di output per il servlet. Questo flusso viene utilizzato, ad esempio, per l'output di file binari. I dati di testo possono essere emessi utilizzando java.io.Writer: public java.io.PrintWriter getWriter () genera java.io.IOException Questo metodo converte automaticamente le stringhe nel set di caratteri specificato nei metodi getCharacterEncoding () e getLocale (). public void setContentLength (int len) Questo metodo imposta il valore del campo di intestazione HTTP "Content-Length" public void setContentType (String type) Metodo per l'invio del tipo di contenuto MIME del documento. Campo di intestazione HTTP "Content-Type". public void setBufferSize (int size) public int getBufferSize () public void flushBuffer () genera java.io.IOException public void resetBuffer () Il punto è che il flusso di output è memorizzato nel buffer. Ciò significa che il successivo blocco di dati verrà inviato al client solo dopo che il buffer è pieno. Questi metodi consentono, rispettivamente, di impostare la dimensione del buffer di invio, ottenere la sua dimensione, inizializzare l'invio del contenuto del buffer al client senza attendere che si riempia e anche cancellare questo buffer di dati. public boolean isCommitted() Con questo metodo è possibile ottenere un flag se l'invio dei dati al client è già iniziato. Il flag sarà positivo se l'intestazione della risposta HTTP è già stata inviata. public void reset() Se l'intestazione HTTP non è stata ancora inviata, questo metodo "reimposta" l'intestazione HTTP ai suoi valori "predefiniti".

Tipi di servlet predefiniti

L'API Java Servlet, oltre alle interfacce effettive, contiene anche diverse classi servlet che possono fungere da base per i tuoi programmi.

La base per tutte queste classi è la classe astratta javax.servlet.GenericServlet:

La classe astratta pubblica GenericServlet implementa Servlet, ServletConfig, java.io.Serializable

Come puoi vedere dalla definizione di questa classe, ha tutti i metodi delle interfacce Servlet e ServletConfig. L'unico metodo non implementato è

Il servizio public abstract void (ServletRequest req, ServletResponse res) genera ServletException, java.io.IOException che è stata dichiarata abstract.

Sulla base di questa classe, è stata creata un'altra classe astratta - javax.servlet.http.HttpServlet:

La classe astratta pubblica HttpServlet estende GenericServlet implementa java.io.Serializable

Questa classe è stata creata secondo il concetto di "ancora più convenienza per il programmatore" e ha molti metodi utili:

Protected void doDelete (HttpServletRequest req, HttpServletResponse resp) genera ServletException, java.io.IOException protected void doGet (HttpServletRequest req, HttpServletResponse resp) genera Servlet. HttpServletResponse resp) genera ServletException, java.io.IOException protetto void doPost (HttpServletRequest req, HttpServletResponse resp) genera Servlet.Exception genera ServletException, java.io.IOException protetto void doTrace (HttpServletRequest req) Servizio void protetto da IOException (HttpServletRequest req, HttpServ throwResvlet resp. , ServletR esponse res) genera ServletException, java.io.IOException Diverse opzioni di servizio (ServletRequest req, ServletResponse res) per diversi metodi HTTP da DELETE e GET a PUT e TRACE. E per ricevere comodamente i dati tramite l'interfaccia CGI senza decifrare l'intestazione, sono state create le classi HttpServletRequest e HttpServletResponse, che sono incluse con HttpServlet nel pacchetto javax.servlet.http protected long getLastModified (HttpServletRequest req) Questo metodo restituisce l'ora dell'ultima modifica dell'oggetto HttpServlet req Prende il valore dell'ora dal campo "Date" dell'intestazione della richiesta HTTP. Se il campo non viene trovato, restituisce -1.

Di conseguenza, analizzeremo le interfacce HttpServletRequest e HttpServletResponse. Ereditano rispettivamente da ServletRequest e ServletResponse.

HttpServletRequest, oltre ai metodi ereditati da ServletRequest, ha anche i seguenti metodi molto utili:

Cookie getCookies() Restituisce l'insieme di cookie inviati dal client al server.

La classe Cookie, che fa parte dello stesso pacchetto javax.servlet.http, contiene tutte le possibili informazioni su un cookie. I metodi più importanti di questa classe sono

Int getMaxAge() String getName() String getValue() che fornisce, rispettivamente, quanto tempo rimane da vivere a questo cookie, il nome del cookie e il suo valore. Anche Cookie (String name, String value) void setValue (String newValue) void setMaxAge (int scadenza) per creare un cookie, impostarne il valore e l'età massima. long getDateHeader (nome stringa) Restituisce la data dall'intestazione HTTP, se presente. int getIntHeader (java.lang.String name) Restituisce il valore numerico del campo denominato name dall'intestazione della richiesta HTTP String getMethod() Restituisce il metodo di richiesta HTTP. String getQueryString () String getRequestURI () StringBuffer getRequestURL () Restituisce la stringa contenuta nell'URL del documento dopo il carattere "?", l'URI del documento e l'URL completo. HttpSession getSession () HttpSession getSession (creazione booleana) booleano isRequestedSessionIdFromCookie () booleano isRequestedSessionIdFromURL () booleano isRequestedSessionIdValid () Funzioni. permettendoti di lavorare con un meccanismo di trasferimento dati così importante come le sessioni.

Le sessioni sono necessarie per trascinare i dati da una pagina all'altra dopo l'utente. Ad esempio, un utente visita la pagina (1), dove gli vengono inviati alcuni dati per la pagina (2) e quello salva altre cose per la pagina (3).

In linea di principio, nella pagina (1) puoi inviare i dati all'utente, quindi scaricarli sulla pagina (2), aggiungere qualcosa, inviarlo all'utente ... In questo modo, dovrai inviare costantemente l'intero set di dati dal client al server e viceversa, e molte volte. Oltre al fatto che tale inoltro non è sempre conveniente, divora anche il traffico.

Puoi fare lo stesso in modo diverso: usa il meccanismo di sessione. Questo meccanismo funziona come segue: i dati inviati dall'utente vengono salvati dal server in un file separato - il file di sessione. Tutto il lavoro sulla modifica dei dati verrà eseguito con il contenuto di questo file. Al client viene assegnata una "chiave di sessione" (nota anche come chiave di sessione, alias Sesseion ID) - un puntatore univoco a un file contenente dati specifici per questo utente. Ora, per ottenere tutti i dati relativi a questo client, il server deve solo conoscere la chiave di sessione. Il vantaggio di questo metodo è la praticità e la velocità del suo utilizzo.

Questi sono tutti i metodi principali dell'interfaccia HttpServletRequest. Per un elenco completo dei metodi, vedere la documentazione dell'API Java Servlet.

Ora sull'interfaccia HttpServletRequest. La differenza principale tra le classi che condividono questa interfaccia è che i dati non vengono emessi immediatamente. Innanzitutto, tutti i dati vengono raggruppati in una risposta HTTP. La risposta viene inviata solo al termine dell'esecuzione di HttpServlet.service().

E quindi, sui metodi:

Void addHeader (nome stringa, valore stringa) void addIntHeader (nome stringa, valore int) void addDateHeader (nome stringa, data lunga) I metodi aggiungono parametri all'intestazione HTTP. L'ultimo metodo imposta il parametro "Date". void addCookie (Cookie cookie) Il metodo aggiunge un cookie all'intestazione booleano contieneHeader (Nome stringa) Consente di scoprire se l'intestazione contiene già il parametro specificato. String encodeURL (String url) String encodeRedirectURL (String url) Il primo metodo codifica i caratteri utilizzando la sostituzione % NN. Il secondo metodo fa lo stesso e chiama void sendRedirect (String location) void setStatus (int sc) void sendError (int sc) void sendError (int sc, String msg) Il primo imposta il codice di ritorno, i secondi due inviano un messaggio di errore . L'interfaccia presenta i seguenti possibili errori per il parametro sc, corrispondenti ai codici di ritorno del protocollo HTTP: SC_CONTINUE - Codice di stato (100) SC_SWITCHING_PROTOCOLS - Codice di stato (101) SC_OK - Codice di stato (200) SC_CREATED - Codice di stato (201) SC_ACCEPTED - Codice di stato (202) SC_NON_AUTHORITATIVE_INFORMATION - Codice di stato (203) SC_NO_CONTENT - Codice di stato (204) SC_RESET_CONTENT - Codice di stato (205) SC_PARTIAL_CONTENT - Codice di stato (206) SC_MULTIPLE_CHOICES (Status_MULTIPLE_CHOICES - Codice di stato (300) SCAN_MOVED_CODICE2) 303) SC_NOT_MODIFIED - Codice di stato (304) SC_USE_PROXY - Codice di stato (305) SC_BAD_REQUEST - Codice di stato (400) SC_UNAUTHORIZED - Codice di stato (401) SC_PAYMENT_REQUIRED - Codice di stato (402) SC_FORBID (Codice di stato) - Codice di stato (404) SC_METHOD_NOT_ALLOW Codice di stato (405) SC_NOT_ACCEPTABLE - Codice di stato (406) SC_PROXY_AUTHENTICATION_REQUIRED - Codice di stato (407) SC_REQUEST_TIMEOUT - Stato Codice s (408) SC_CONFLICT - Codice di stato (409) SC_GONE - Codice di stato (410) SC_LENGTH_REQUIRED - Codice di stato (411) SC_PRECONDITION_FAILED - Codice di stato (412) SC_REQUEST_ENTITY_TOO_LARGE - Codice di stato (413) SC_RETOOEST) codice di stato (415) SC_REQUESTEDSAT_RANGE_NO (416) SC_EXPECTATION_FAILED - Codice di stato (417) SC_INTERNAL_SERVER_ERROR - Codice di stato (500) SC_NOT_IMPLEMENTED - Codice di stato SC_BAD_GATEW2) (504) SC_HTTP_VERSION_NOT_SUPPORTED - Codice di stato (505)

Questo è tutto quello che c'è da dire su HttpServletResponse

Utilizzo delle servlet nelle applicazioni WEB

Ora parliamo dell'utilizzo dei servlet nelle applicazioni WEB. Per fare ciò, fornirò due esempi utili che possono essere utili nella pratica.

Il primo esempio mostra i metodi per lavorare con un HttpServlet e visualizzare il contenuto della pagina HTML compresso. In teoria, la pagina HTML nella risposta del browser viene visualizzata in testo normale, ma per ridurre la quantità di dati inviati, è possibile utilizzare la compressione GZIP. I browser moderni (almeno i browser di quarta generazione e superiori) supportano questo metodo di invio di informazioni testuali e renderanno la pagina come se non fosse stata compressa.

importa java. io.*; importa javax. servlet.*; importa javax. servlet. http.*; importa java. utile. cerniera lampo. *; // servlet eredita da HttpServlet la classe pubblica ZipServlet estende HttpServlet ( // funzione per gestire il metodo GET public void doGet (richiesta HttpServletRequest, risposta HttpServletResponse) genera ServletException, IOException ( // imposta la pagina come documento HTML risposta. setContentType ("testo/html"); // prendi il parametro "Accept-Encoding" dall'intestazione HTTP Codifiche stringa = richiesta. getHeader ("Accetta-codifica"); // prendi il parametro "encoding" - la codifica del documento precedentemente specificata String encodeFlag = richiesta. getParameter ("codifica"); // Dove produrremo StampaWriter fuori; // se nella richiesta è presente il campo "Accept-Encoding" if (codifiche! = null) ( // e se questo campo contiene il valore "gzip" e la codifica non è stata ancora impostata, if ((codifiche. indexOf ("gzip")! = - 1) &&! encodeFlag. equals ("none")) ( // quindi l'output sarà seguito da uno e comprimerà il testo usando GZIP out = new PrintWriter (new GZIPOutputStream (response. getOutputStream ()), false); // e imposta un flag per il browser che il documento verrà compresso risposta. setHeader ("Codifica del contenuto", "gzip"); ) altrimenti fuori = risposta. getWriter (); ) altro // altrimenti produrremo senza compressione fuori = risposta. getWriter (); fuori. println ("Questo è un test !!!"); // scrivo il corpo del documento fuori. chiudere (); // e chiude l'output. // Tutto, al termine del lavoro di questa funzione, verrà inviato il documento } }

Il secondo esempio mostra come un servlet può eseguire il rendering di una pagina in modo continuo. Questo tipo di visualizzazione della pagina può essere utilizzato, ad esempio, nelle chat: per leggere nuovi messaggi, non sarà necessario aggiornare ogni volta la pagina, i nuovi messaggi verranno semplicemente scaricati nel tempo. Va notato che alcuni server proxy non supportano questo tipo di trasferimento dati, ma con questo - ahimè - non si può fare nulla.

importa java. io.*; importa javax. servlet.*; // il programma implementa l'interfaccia Servlet class DoloadServlet implementa Servlet (ServletConfig config; // ServletConfig oggetto public DoloadServlet () () // facendo nulla // salva la configurazione durante l'inizializzazione public void init (ServletConfig config) genera ServletException (this. config = config;) // fornisce la configurazione salvata public ServletConfig getServletConfig() (restituisce config;) // informazioni servlet public String getServletInfo () (restituisce "DoloadServlet";) public void destroy () () // facendo nulla // Richiesta di elaborazione il servizio public void (richiesta ServletRequest, risposta ServletResponse) genera ServletException, java. io. IOException ( // non analizzeremo la richiesta, è solo un casino // crea un'intestazione HTTP: String head = "HTTP / 1.0 200 OK \ n" + + "Server: DoloadServlet \ n" + "Tipo di contenuto: testo / html; set di caratteri = UTF-8 \ n"+ "Connessione: Keep-Alive \ n" + "Codifica del contenuto: multiparte / misto \ n"+ "Codifica trasferimento: chunked" + "Pragma: no-cache \ n \ n"; // ora aggiungi i dati iniziali // per questo esempio - 20 tag "
"con interruzione di riga per (int i = 0; i< 20 ; i++ ) head = head + "
\ n "; // prende il flusso di output ServletOutputStream os = risposta. getOutputStream (); // scrivi il titolo e i dati iniziali lì os. stampa (testa); // invia tutto ciò che è scritto nel buffer al client risposta. flushBuffer(); // inizia ad aggiungere nuove righe: // queste righe avranno questo aspetto: numero di riga, quindi "
\ n " // ogni nuova riga apparirà ogni 3 secondi int i = 0; mentre (vero) ( // incrementa il contatore io++; // scrivo la riga os. stampa ("" + io + "
\ n "); // svuota il buffer response.flushBuffer (); // blocca il flusso per 3 secondi try (sleep (3000);) catch (Eccezione e) ())))

Resta da dire che il meccanismo della servlet è molto flessibile e permette di creare cose che potrebbero richiedere la scrittura di un WEB server separato (come, ad esempio, nel caso di un resume servlet). Gli svantaggi dei servlet sono la bassa velocità del primo avvio (il servlet viene semplicemente compilato dalla macchina JIT), l'elevato consumo di memoria e la mancanza di tutti i programmi Java: la bassa velocità di lavoro con le stringhe. Quest'ultima circostanza diventa evidente quando funzionano i servlet che accettano dati di testo nelle richieste POST. Una richiesta POST di 50 KB a un HttpServlet durante l'analisi con HttpServletRequest.getReader() può paralizzare il server per un paio di minuti. Lo stesso vale per altri programmi Java.

Ecco due piccoli esempi:

// data una stringa Stringa testo // esempio 1 // lavorare con una stringa usando l'operazione "+" per String Prova stringa1 = ""; per (int i = 0; i< text. length(); i++ ) test1 += text. charAt(i); // esempio 2 // lavorare con una stringa usando un buffer char buf = nuovo carattere [testo. lunghezza ()]; per (int i = 0; i< text. length(); i++ ) buf[ i] = text. charAt(i); String sample2 = new String(buf);

Se prendiamo piccole stringhe - fino a 2-3 kb, le differenze nel lavoro degli esempi sono insignificanti, ma se prendiamo un testo di stringa con una dimensione di almeno 10 kb, nel primo caso il programma funzionerà con la corda molto più lenta. Questa è una funzionalità Java ed è un problema nell'implementazione delle funzioni della classe String. Quindi, se vuoi scrivere un servlet veloce, evita di lavorare con stringhe lunghe attraverso la classe String, ad esempio usa la classe StringBuffer. Questo avviso si applica principalmente alla ricezione di testi di grandi dimensioni dalla rete e all'elaborazione di file locali (ad esempio, nel caso di un database di testo per un libro degli ospiti con un numero elevato di messaggi).

Un altro problema riguarda il multitasking del sistema WEB. Tieni presente che più utenti possono richiedere il tuo servlet contemporaneamente. Ci sono spesso problemi con la sincronizzazione dei dati, lo scambio di informazioni tra diversi thread di calcolo dello stesso servlet e il problema più comune è il problema dell'accesso sincrono ai file e ad altre risorse di sistema denominate. Ad esempio, un programma ha aperto un file per la lettura, mentre un altro sta cercando di scrivere qualcosa lì. Di conseguenza, il secondo programma riceve un'eccezione o attende che il file venga liberato per la scrittura. A questo proposito vorrei richiamare la vostra attenzione: non lasciate dietro di voi ruscelli non chiusi e chiudete ruscelli appena non ce n'è più bisogno. Lo stream, ovviamente, si chiuderà automaticamente in seguito, ma ciò accadrà solo quando lo "scavenger" lo raggiunge, e nel frattempo il secondo programma non avrà ancora accesso in scrittura al file.

Oltre al multitasking, vorrei notare che utilizzando i metodi "Object getAttribute (String name)" e "void setAttribute (String name, Object object)" dell'interfaccia ServletContext, è possibile scambiare dati tra servlet, inclusa la sincronizzazione dei dati.

Il servlet di esempio include il servlet HelloWorld.java stesso e il descrittore dell'applicazione web.xml. Servlet ti consente di formare una pagina di risposta utilizzando l'alfabeto cirillico. La struttura di un servlet di esempio nell'IDE Eclipse è mostrata nella schermata seguente.

Elenco di esempio di servlet HelloWorld.java

Il codice seguente implementa un semplice servlet HelloWorld.java che restituisce una pagina HTML statica al browser. Nell'esempio, il servlet eredita le proprietà dell'HttpServlet che implementa l'interfaccia servlet.

Importa java.io.IOException; import java.io.OutputStream; import javax.servlet.ServletConfig; import javax.servlet.http.HttpServlet; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class HelloWorld estende HttpServlet (configurazione ServletConfig privata; @Override public void init (configurazione ServletConfig) genera ServletException (this.config = config;) @Override public void destroy () () @Override public ServletConfig getServletConfig () (restituisce config;) @Override public String getServletInfo () (return "A Simple Servlet";) public void service (richiesta HttpServletRequest, risposta HttpServletResponse) genera ServletException, IOException (response.setContentType ("text / html"); String text = " " + "" + " " + "Esempio di servlet!" + "" + "" + "

Ciao% s% s!

"+" "; text = String.format (text, config.getInitParameter (" name "), config.getInitParameter (" mname ")); OutputStream outStream = response.getOutputStream (); outStream.write (text.getBytes (" UTF-8 ")); outStream.flush (); outStream.close ();))

Quando si accede al servlet, viene chiamato il metodo servizio che visualizza una pagina di risposta e la passa al browser tramite HttpServletResponse. Le prime righe della risposta del server definiscono l'intestazione Tipo di contenuto con l'indicazione della codifica UTF-8. Inoltre, il nome e il patronimico ricevuti dal descrittore dell'applicazione web.xml vengono sostituiti nel modello di risposta. Cioè, legge i parametri di configurazione del servlet.

Per poter restituire una pagina con il cirillico, utilizzare OutputStream... Qualsiasi informazione può essere inviata al flusso di output (nel nostro esempio, semplice codice HTML).

Elenco dei descrittori dell'applicazione XML

Servlet Hello World Ciao esempio.HelloWorld nome Ostap mname Ibrahimovic Ciao / Ciao

Nel descrittore dell'applicazione web.xml Sono definiti i parametri servlet (nome nome-servlet e classe classe-servlet) ei parametri di inizializzazione (nome nome, secondo nome mname). Il servlet legge questi parametri usando Configurazione servlet.

Per eseguire il servlet di esempio dall'IDE Eclipse, avviare il server delle applicazioni e immettere la seguente riga nella barra degli indirizzi del browser:

Http: // localhost: 8080 / ServletHello / ciao

Il browser ci mostrerà un saluto che indica il personaggio principale delle opere di Ilf e Petrov.

Per compilare il servlet separatamente, puoi utilizzare un file batch, il cui testo per Windows potrebbe essere simile a questo.

SET TOMCAT_LIB = "C: \ Program Files \ Apache Software Foundation \ Tomcat \ common \ lib" SET JAVA_SDK = C: \ Java \ Sun \ SDK \ jdk \ bin \% JAVA_SDK% javac -classpath% TOMCAT_LIB% \ servlet-api. vaso * .java

Dopo aver compilato il servlet HelloWorld.class deve essere inserito nella directory WEB-INF / classi / Applicazioni WEB su server Tomcat e registrarsi nel descrittore di consegna web.xml.

Scarica esempio

Il codice sorgente della servlet di esempio discussa nel testo della pagina può essere (191 KB).

È possibile visualizzare un esempio di servlet che utilizza la libreria grafica Chart.js per generare dinamicamente una pagina con grafici.

LA CAMPANA