Servlets - Guia rápido
O que são servlets?
Servlets Java são programas executados em um servidor da Web ou de aplicativos e atuam como uma camada intermediária entre as solicitações provenientes de um navegador da Web ou outro cliente HTTP e bancos de dados ou aplicativos no servidor HTTP.
Usando Servlets, você pode coletar dados de usuários por meio de formulários de página da web, apresentar registros de um banco de dados ou outra fonte e criar páginas da web dinamicamente.
Servlets Java geralmente têm a mesma finalidade que os programas implementados usando a Common Gateway Interface (CGI). Mas os Servlets oferecem várias vantagens em comparação com o CGI.
O desempenho é significativamente melhor.
Os servlets são executados no espaço de endereço de um servidor web. Não é necessário criar um processo separado para lidar com cada solicitação do cliente.
Os servlets são independentes de plataforma porque são escritos em Java.
O gerenciador de segurança Java no servidor impõe um conjunto de restrições para proteger os recursos em uma máquina servidor. Portanto, os servlets são confiáveis.
A funcionalidade completa das bibliotecas de classes Java está disponível para um servlet. Ele pode se comunicar com applets, bancos de dados ou outro software por meio de soquetes e mecanismos RMI que você já viu.
Arquitetura Servlets
O diagrama a seguir mostra a posição dos Servlets em um aplicativo da web.
Tarefas de servlets
Os servlets realizam as seguintes tarefas principais -
Leia os dados explícitos enviados pelos clientes (navegadores). Isso inclui um formulário HTML em uma página da Web ou também pode vir de um miniaplicativo ou programa cliente HTTP personalizado.
Leia os dados de solicitação HTTP implícitos enviados pelos clientes (navegadores). Isso inclui cookies, tipos de mídia e esquemas de compactação que o navegador entende e assim por diante.
Processe os dados e gere os resultados. Esse processo pode exigir a comunicação com um banco de dados, a execução de uma chamada RMI ou CORBA, a invocação de um serviço da Web ou o cálculo direto da resposta.
Envie os dados explícitos (ou seja, o documento) para os clientes (navegadores). Este documento pode ser enviado em uma variedade de formatos, incluindo texto (HTML ou XML), binário (imagens GIF), Excel, etc.
Envie a resposta HTTP implícita aos clientes (navegadores). Isso inclui informar aos navegadores ou outros clientes que tipo de documento está sendo retornado (por exemplo, HTML), definir cookies e parâmetros de cache e outras tarefas semelhantes.
Pacotes de servlets
Java Servlets são classes Java executadas por um servidor da web que possui um interpretador que suporta a especificação Java Servlet.
Servlets podem ser criados usando o javax.servlet e javax.servlet.http pacotes, que são uma parte padrão da edição empresarial do Java, uma versão expandida da biblioteca de classes Java que oferece suporte a projetos de desenvolvimento em grande escala.
Essas classes implementam as especificações Java Servlet e JSP. No momento em que este tutorial foi escrito, as versões eram Java Servlet 2.5 e JSP 2.1.
Os servlets Java foram criados e compilados como qualquer outra classe Java. Depois de instalar os pacotes de servlet e adicioná-los ao Classpath do seu computador, você pode compilar servlets com o compilador Java do JDK ou qualquer outro compilador atual.
O que vem a seguir?
Eu o orientaria passo a passo para configurar seu ambiente para iniciar com Servlets. Portanto, aperte o cinto para uma boa movimentação com Servlets. Tenho certeza que você vai gostar muito deste tutorial.
Um ambiente de desenvolvimento é onde você desenvolveria seu Servlet, testaria e finalmente executaria.
Como qualquer outro programa Java, você precisa compilar um servlet usando o compilador Java javac e após a compilação do aplicativo servlet, ele seria implantado em um ambiente configurado para testar e executar.
Esta configuração do ambiente de desenvolvimento envolve as seguintes etapas -
Configurando o Java Development Kit
Esta etapa envolve o download de uma implementação do Java Software Development Kit (SDK) e a configuração da variável de ambiente PATH apropriadamente.
Você pode baixar o SDK do site Java da Oracle - Java SE Downloads .
Depois de baixar sua implementação Java, siga as instruções fornecidas para instalar e configurar a configuração. Por fim, defina as variáveis de ambiente PATH e JAVA_HOME para se referir ao diretório que contém java e javac, normalmente java_install_dir / bin e java_install_dir, respectivamente.
Se você estiver executando o Windows e tiver instalado o SDK em C: \ jdk1.8.0_65, coloque a seguinte linha em seu arquivo C: \ autoexec.bat.
set PATH = C:\jdk1.8.0_65\bin;%PATH%
set JAVA_HOME = C:\jdk1.8.0_65Alternativamente, no Windows NT / 2000 / XP, você também pode clicar com o botão direito do mouse em Meu computador, selecionar Propriedades, Avançado e Variáveis de ambiente. Em seguida, você atualizaria o valor de PATH e pressionaria o botão OK.
No Unix (Solaris, Linux, etc.), se o SDK for instalado em /usr/local/jdk1.8.0_65 e você usar o shell C, você deve colocar o seguinte em seu arquivo .cshrc.
setenv PATH /usr/local/jdk1.8.0_65/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.8.0_65Como alternativa, se você usar um Ambiente de Desenvolvimento Integrado (IDE) como Borland JBuilder, Eclipse, IntelliJ IDEA ou Sun ONE Studio, compile e execute um programa simples para confirmar que o IDE sabe onde você instalou o Java.
Configurando o servidor web - Tomcat
Vários servidores da Web que oferecem suporte a servlets estão disponíveis no mercado. Alguns servidores web podem ser baixados gratuitamente e o Tomcat é um deles.
Apache Tomcat é uma implementação de software de código aberto das tecnologias Java Servlet e Java Server Pages e pode atuar como um servidor autônomo para testar servlets e pode ser integrado ao Apache Web Server. Aqui estão as etapas para configurar o Tomcat em sua máquina -
Baixe a última versão do Tomcat de https://tomcat.apache.org/.
Depois de fazer o download da instalação, descompacte a distribuição binária em um local conveniente. Por exemplo, em C: \ apache-tomcat-8.0.28 no Windows ou /usr/local/apache-tomcat-8.0.289 no Linux / Unix e crie a variável de ambiente CATALINA_HOME apontando para esses locais.
O Tomcat pode ser iniciado executando os seguintes comandos na máquina Windows -
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-8.0.28\bin\startup.batO Tomcat pode ser iniciado executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-8.0.28/bin/startup.shApós a inicialização, os aplicativos da web padrão incluídos no Tomcat estarão disponíveis visitando http://localhost:8080/. Se tudo estiver bem, ele deve exibir o seguinte resultado -
Mais informações sobre como configurar e executar o Tomcat podem ser encontradas na documentação incluída aqui, bem como no site do Tomcat - http://tomcat.apache.org
O Tomcat pode ser interrompido executando os seguintes comandos na máquina Windows -
C:\apache-tomcat-8.0.28\bin\shutdownO Tomcat pode ser interrompido executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -
/usr/local/apache-tomcat-8.0.28/bin/shutdown.shConfigurando o CLASSPATH
Como os servlets não fazem parte da plataforma Java, Standard Edition, você deve identificar as classes de servlet para o compilador.
Se estiver executando o Windows, você precisará inserir as seguintes linhas no arquivo C: \ autoexec.bat.
set CATALINA = C:\apache-tomcat-8.0.28
set CLASSPATH = %CATALINA%\common\lib\servlet-api.jar;%CLASSPATH%Alternativamente, no Windows NT / 2000 / XP, você pode ir para Meu Computador -> Propriedades -> Avançado -> Variáveis de Ambiente. Em seguida, você atualizaria o valor CLASSPATH e pressionaria o botão OK.
No Unix (Solaris, Linux, etc.), se estiver usando o shell C, você deve colocar as seguintes linhas em seu arquivo .cshrc.
setenv CATALINA = /usr/local/apache-tomcat-8.0.28
setenv CLASSPATH $CATALINA/common/lib/servlet-api.jar:$CLASSPATHNOTE - Supondo que seu diretório de desenvolvimento seja C: \ ServletDevel (Windows) ou / usr / ServletDevel (Unix), você precisará adicionar esses diretórios também em CLASSPATH de maneira semelhante à que adicionou acima.
O ciclo de vida de um servlet pode ser definido como o processo completo, desde sua criação até a destruição. A seguir estão os caminhos seguidos por um servlet.
O servlet é inicializado chamando o init() método.
As chamadas de servlet service() método para processar a solicitação de um cliente.
O servlet é encerrado chamando o destroy() método.
Finalmente, o servlet é coletado como lixo pelo coletor de lixo da JVM.
Agora vamos discutir os métodos do ciclo de vida em detalhes.
O Método init ()
O método init é chamado apenas uma vez. Ele é chamado apenas quando o servlet é criado e não é chamado para nenhuma solicitação do usuário posteriormente. Portanto, ele é usado para inicializações únicas, assim como com o método init dos miniaplicativos.
O servlet é normalmente criado quando um usuário chama pela primeira vez um URL correspondente ao servlet, mas você também pode especificar que o servlet seja carregado quando o servidor for iniciado pela primeira vez.
Quando um usuário invoca um servlet, uma única instância de cada servlet é criada, com cada solicitação do usuário resultando em um novo encadeamento que é transferido para doGet ou doPost conforme apropriado. O método init () simplesmente cria ou carrega alguns dados que serão usados durante a vida do servlet.
A definição do método init se parece com isto -
public void init() throws ServletException {
// Initialization code...
}O método service ()
O método service () é o principal método para executar a tarefa real. O contêiner de servlet (ou seja, servidor da web) chama o método service () para lidar com solicitações vindas do cliente (navegadores) e para escrever a resposta formatada de volta para o cliente.
Cada vez que o servidor recebe uma solicitação de um servlet, o servidor gera um novo thread e chama o serviço. O método service () verifica o tipo de solicitação HTTP (GET, POST, PUT, DELETE, etc.) e chama os métodos doGet, doPost, doPut, doDelete, etc. conforme apropriado.
Aqui está a assinatura deste método -
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException {
}O método service () é chamado pelo contêiner e o método de serviço invoca os métodos doGet, doPost, doPut, doDelete, etc. conforme apropriado. Portanto, você não tem nada a ver com o método service (), mas substitui doGet () ou doPost () dependendo do tipo de solicitação que você recebe do cliente.
O doGet () e doPost () são os métodos usados com mais frequência em cada solicitação de serviço. Aqui está a assinatura desses dois métodos.
Método doGet ()
Uma solicitação GET resulta de uma solicitação normal de um URL ou de um formulário HTML que não tem nenhum MÉTODO especificado e deve ser tratada pelo método doGet ().
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}Método doPost ()
Uma solicitação POST resulta de um formulário HTML que lista especificamente POST como o MÉTODO e deve ser tratada pelo método doPost ().
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}O método destroy ()
O método destroy () é chamado apenas uma vez no final do ciclo de vida de um servlet. Este método dá ao seu servlet a chance de fechar conexões de banco de dados, interromper threads em segundo plano, gravar listas de cookies ou contagens de ocorrências no disco e executar outras atividades de limpeza.
Depois que o método destroy () é chamado, o objeto servlet é marcado para coleta de lixo. A definição do método destroy se parece com isto -
public void destroy() {
// Finalization code...
}Diagrama de Arquitetura
A figura a seguir descreve um cenário típico de ciclo de vida de servlet.
Primeiro, as solicitações HTTP que chegam ao servidor são delegadas ao contêiner de servlet.
O contêiner de servlet carrega o servlet antes de invocar o método service ().
Em seguida, o contêiner de servlet lida com várias solicitações gerando vários threads, cada thread executando o método service () de uma única instância do servlet.
Servlets são classes Java que atendem a solicitações HTTP e implementam o javax.servlet.Servletinterface. Os desenvolvedores de aplicativos da Web normalmente escrevem servlets que estendem javax.servlet.http.HttpServlet, uma classe abstrata que implementa a interface Servlet e é especialmente projetada para lidar com solicitações HTTP.
Código de amostra
A seguir está o exemplo de estrutura de código-fonte de um exemplo de servlet para mostrar 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.
}
}Compilando um Servlet
Vamos criar um arquivo com o nome HelloWorld.java com o código mostrado acima. Coloque este arquivo em C: \ ServletDevel (no Windows) ou em / usr / ServletDevel (no Unix). Este local de caminho deve ser adicionado a CLASSPATH antes de prosseguir.
Supondo que seu ambiente esteja configurado corretamente, entre ServletDevel diretório e compilar HelloWorld.java da seguinte maneira -
$ javac HelloWorld.javaSe o servlet depende de qualquer outra biblioteca, você deve incluir esses arquivos JAR em seu CLASSPATH também. Incluí apenas o arquivo JAR servlet-api.jar porque não estou usando nenhuma outra biblioteca no programa Hello World.
Esta linha de comando usa o compilador javac integrado que vem com o Sun Microsystems Java Software Development Kit (JDK). Para que esse comando funcione corretamente, você deve incluir a localização do Java SDK que está usando na variável de ambiente PATH.
Se tudo correr bem, a compilação acima produzirá HelloWorld.classarquivo no mesmo diretório. A próxima seção explicaria como um servlet compilado seria implantado na produção.
Implementação de servlet
Por padrão, um aplicativo servlet está localizado no caminho <Tomcat-installationdirectory> / webapps / ROOT e o arquivo de classe deve residir em <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Se você tiver um nome de classe totalmente qualificado de com.myorg.MyServlet, essa classe de servlet deve estar localizada em WEB-INF / classes / com / myorg / MyServlet.class.
Por enquanto, vamos copiar HelloWorld.class em <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes e criar as seguintes entradas em web.xml arquivo localizado em <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>As entradas acima devem ser criadas dentro das tags <web-app> ... </web-app> disponíveis no arquivo web.xml. Pode haver várias entradas disponíveis nesta tabela, mas não importa.
Você está quase terminando, agora vamos iniciar o servidor tomcat usando <Tomcat-installationdirectory> \ bin \ startup.bat (no Windows) ou <Tomcat-installationdirectory> /bin/startup.sh (no Linux / Solaris etc.) e finalmente digite http://localhost:8080/HelloWorldna caixa de endereço do navegador. Se tudo correr bem, você obterá o seguinte resultado
Você deve ter se deparado com muitas situações em que precisa passar algumas informações de seu navegador para o servidor da web e, finalmente, para o programa de back-end. O navegador usa dois métodos para passar essas informações ao servidor da web. Esses métodos são o Método GET e o Método POST.
Método GET
O método GET envia as informações codificadas do usuário anexadas à solicitação de página. A página e as informações codificadas são separadas pelo? (ponto de interrogação) símbolo da seguinte forma -
http://www.test.com/hello?key1 = value1&key2 = value2O método GET é o método padrão para passar informações do navegador para o servidor da web e produz uma longa string que aparece na caixa Location: do seu navegador. Nunca use o método GET se você tiver uma senha ou outras informações confidenciais para passar para o servidor. O método GET tem limitação de tamanho: apenas 1024 caracteres podem ser usados em uma string de solicitação.
Esta informação é passada usando o cabeçalho QUERY_STRING e estará acessível através da variável de ambiente QUERY_STRING e o Servlet lida com este tipo de requisição usando doGet() método.
Método POST
Um método geralmente mais confiável de passar informações para um programa de back-end é o método POST. Isso empacota as informações exatamente da mesma maneira que o método GET, mas em vez de enviá-las como uma string de texto após um? (ponto de interrogação) no URL, ele o envia como uma mensagem separada. Esta mensagem chega ao programa de backend na forma de entrada padrão que você pode analisar e usar para seu processamento. O servlet lida com este tipo de solicitações usandodoPost() método.
Leitura de dados de formulário usando servlet
Os servlets tratam da análise de dados do formulário automaticamente usando os seguintes métodos, dependendo da situação -
getParameter() - Você chama o método request.getParameter () para obter o valor de um parâmetro de formulário.
getParameterValues() - Chame este método se o parâmetro aparecer mais de uma vez e retornar vários valores, por exemplo, caixa de seleção.
getParameterNames() - Chame esse método se quiser uma lista completa de todos os parâmetros na solicitação atual.
Exemplo de método GET usando URL
Aqui está uma URL simples que passará dois valores para o programa HelloForm usando o método GET.
http://localhost:8080/HelloForm?first_name = ZARA&last_name = ALIDado abaixo é o HelloForm.javaprograma servlet para lidar com a entrada fornecida pelo navegador da web. Vamos usargetParameter() método que torna muito fácil acessar as informações passadas -
// 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>"
);
}
}Supondo que seu ambiente esteja configurado corretamente, compile HelloForm.java da seguinte maneira -
$ javac HelloForm.javaSe tudo correr bem, a compilação acima produzirá HelloForm.classArquivo. Em seguida, você teria que copiar este arquivo de classe em <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes e criar as seguintes entradas emweb.xml arquivo localizado em <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>Agora digite http: // localhost: 8080 / HelloForm? First_name = ZARA & last_name = ALI na caixa Location: do seu navegador e certifique-se de que você já iniciou o servidor tomcat, antes de disparar o comando acima no navegador. Isso geraria o seguinte resultado -
Using GET Method to Read Form Data
- First Name: ZARA
- Last Name: ALI
Exemplo de método GET usando formulário
Aqui está um exemplo simples que passa dois valores usando HTML FORM e o botão de envio. Vamos usar o mesmo Servlet HelloForm para lidar com essa entrada.
<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>Mantenha este HTML em um arquivo Hello.htm e coloque-o no diretório <Tomcat-installationdirectory> / webapps / ROOT. Quando você acessa http: // localhost: 8080 / Hello.htm , aqui está a saída real do formulário acima.
Tente inserir o nome e o sobrenome e clique no botão enviar para ver o resultado em sua máquina local onde o tomcat está sendo executado. Com base na entrada fornecida, ele gerará um resultado semelhante ao mencionado no exemplo acima.
Exemplo de método POST usando formulário
Vamos fazer pequenas modificações no servlet acima, para que ele possa lidar com os métodos GET e POST. Abaixo estáHelloForm.java programa servlet para lidar com a entrada fornecida pelo navegador da web usando os métodos GET ou 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);
}
}Agora compile e implante o Servlet acima e teste-o usando Hello.htm com o método POST da seguinte maneira -
<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>Aqui está a saída real do formulário acima, tente inserir o nome e o sobrenome e clique no botão enviar para ver o resultado em sua máquina local onde o tomcat está sendo executado.
Com base na entrada fornecida, ele geraria um resultado semelhante ao mencionado nos exemplos acima.
Passando Dados da Caixa de Seleção para o Programa Servlet
As caixas de seleção são usadas quando mais de uma opção deve ser selecionada.
Aqui está um exemplo de código HTML, CheckBox.htm, para um formulário com duas caixas de seleção
<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>O resultado deste código é o seguinte formulário
A seguir está o programa servlet CheckBox.java para lidar com a entrada fornecida pelo navegador da web para o botão de caixa de seleção.
// 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);
}
}Para o exemplo acima, ele exibiria o seguinte resultado -
Reading Checkbox Data
- Maths Flag : : on
- Physics Flag: : null
- Chemistry Flag: : on
Lendo todos os parâmetros do formulário
A seguir está o exemplo genérico que usa getParameterNames()método de HttpServletRequest para ler todos os parâmetros de formulário disponíveis. Este método retorna uma Enumeração que contém os nomes dos parâmetros em uma ordem não especificada
Assim que tivermos uma Enumeração, podemos fazer um loop para baixo da Enumeração de maneira padrão, usando o método hasMoreElements () para determinar quando parar e usando o método nextElement () para obter cada nome de parâmetro.
// 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);
}
}Agora, tente o servlet acima com a seguinte forma -
<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>Agora, chamar o servlet usando o formulário acima geraria o seguinte resultado -
Reading All Form Parameters
Param Name
Param Value(s)
maths
on
chemistry
on
Você pode tentar o servlet acima para ler os dados de qualquer outro formulário, tendo outros objetos como caixa de texto, botão de rádio ou caixa suspensa, etc.
Quando um navegador solicita uma página da web, ele envia muitas informações ao servidor da web que não podem ser lidas diretamente porque essas informações viajam como parte do cabeçalho da solicitação HTTP. Você pode verificar o protocolo HTTP para obter mais informações sobre isso.
A seguir estão as informações importantes do cabeçalho que vêm do lado do navegador e que você usaria com muita frequência na programação da web -
| Sr. Não. | Cabeçalho e Descrição |
|---|---|
| 1 | Accept Este cabeçalho especifica os tipos MIME que o navegador ou outros clientes podem manipular. Valores deimage/png ou image/jpeg são as duas possibilidades mais comuns. |
| 2 | Accept-Charset Este cabeçalho especifica os conjuntos de caracteres que o navegador pode usar para exibir as informações. Por exemplo ISO-8859-1. |
| 3 | Accept-Encoding Este cabeçalho especifica os tipos de codificação que o navegador sabe como lidar. Valores degzip ou compress são as duas possibilidades mais comuns. |
| 4 | Accept-Language Este cabeçalho especifica os idiomas preferidos do cliente, caso o servlet possa produzir resultados em mais de um idioma. Por exemplo, en, en-us, ru, etc |
| 5 | Authorization Esse cabeçalho é usado pelos clientes para se identificarem ao acessar páginas da Web protegidas por senha. |
| 6 | Connection Este cabeçalho indica se o cliente pode lidar com conexões HTTP persistentes. As conexões persistentes permitem que o cliente ou outro navegador recupere vários arquivos com uma única solicitação. Um valor deKeep-Alive significa que conexões persistentes devem ser usadas. |
| 7 | Content-Length Este cabeçalho é aplicável apenas a solicitações POST e fornece o tamanho dos dados POST em bytes. |
| 8 | Cookie Este cabeçalho retorna cookies aos servidores que os enviaram anteriormente ao navegador. |
| 9 | Host Este cabeçalho especifica o host e a porta conforme fornecidos no URL original. |
| 10 | If-Modified-Since Este cabeçalho indica que o cliente deseja a página apenas se ela tiver sido alterada após a data especificada. O servidor envia um código 304 que significaNot Modified cabeçalho se nenhum resultado mais recente estiver disponível. |
| 11 | If-Unmodified-Since Este cabeçalho é o reverso de If-Modified-Since; ele especifica que a operação deve ser bem-sucedida apenas se o documento for mais antigo que a data especificada. |
| 12 | Referer Este cabeçalho indica o URL da página da Web de referência. Por exemplo, se você estiver na página 1 da Web e clicar em um link para a página 2 da Web, a URL da página 1 da Web será incluída no cabeçalho Referrer quando o navegador solicitar a página 2 da Web. |
| 13 | User-Agent Este cabeçalho identifica o navegador ou outro cliente que faz a solicitação e pode ser usado para retornar conteúdo diferente para diferentes tipos de navegadores. |
Métodos para ler o cabeçalho HTTP
Existem métodos a seguir que podem ser usados para ler o cabeçalho HTTP em seu programa de servlet. Esses métodos estão disponíveis com o objeto HttpServletRequest
| Sr. Não. | Método e Descrição |
|---|---|
| 1 | Cookie[] getCookies() Retorna uma matriz contendo todos os objetos Cookie que o cliente enviou com esta solicitação. |
| 2 | Enumeration getAttributeNames() Retorna uma Enumeração contendo os nomes dos atributos disponíveis para esta solicitação. |
| 3 | Enumeration getHeaderNames() Retorna uma enumeração de todos os nomes de cabeçalho que esta solicitação contém. |
| 4 | Enumeration getParameterNames() Retorna uma Enumeração de objetos String contendo os nomes dos parâmetros contidos nesta solicitação |
| 5 | HttpSession getSession() Retorna a sessão atual associada a esta solicitação ou, se a solicitação não tiver uma sessão, cria uma. |
| 6 | HttpSession getSession(boolean create) Retorna a HttpSession atual associada a esta solicitação ou, se não houver sessão atual e o valor de criar for verdadeiro, retorna uma nova sessão. |
| 7 | Locale getLocale() Retorna o Locale preferido no qual o cliente aceitará o conteúdo, com base no cabeçalho Accept-Language. |
| 8 | Object getAttribute(String name) Retorna o valor do atributo nomeado como um objeto ou nulo se nenhum atributo com o nome fornecido existir. |
| 9 | ServletInputStream getInputStream() Recupera o corpo da solicitação como dados binários usando um ServletInputStream. |
| 10 | String getAuthType() Retorna o nome do esquema de autenticação usado para proteger o servlet, por exemplo, "BASIC" ou "SSL", ou nulo se o JSP não estiver protegido. |
| 11 | String getCharacterEncoding() Retorna o nome da codificação de caracteres usada no corpo desta solicitação. |
| 12 | String getContentType() Retorna o tipo MIME do corpo da solicitação ou nulo se o tipo não for conhecido. |
| 13 | String getContextPath() Retorna a parte do URI da solicitação que indica o contexto da solicitação. |
| 14 | String getHeader(String name) Retorna o valor do cabeçalho da solicitação especificada como uma String. |
| 15 | String getMethod() Retorna o nome do método HTTP com o qual esta solicitação foi feita, por exemplo, GET, POST ou PUT. |
| 16 | String getParameter(String name) Retorna o valor de um parâmetro de solicitação como String ou nulo se o parâmetro não existe. |
| 17 | String getPathInfo() Retorna qualquer informação de caminho extra associada ao URL que o cliente enviou quando fez esta solicitação |
| 18 | String getProtocol() Retorna o nome e a versão do protocolo da solicitação. |
| 19 | String getQueryString() Retorna a string de consulta contida no URL da solicitação após o caminho. |
| 20 | String getRemoteAddr() Retorna o endereço de protocolo da Internet (IP) do cliente que enviou a solicitação. |
| 21 | String getRemoteHost() Retorna o nome totalmente qualificado do cliente que enviou a solicitação. |
| 22 | String getRemoteUser() Retorna o login do usuário que fez esta solicitação, se o usuário foi autenticado, ou nulo se o usuário não foi autenticado. |
| 23 | String getRequestURI() Retorna a parte do URL desta solicitação do nome do protocolo até a string de consulta na primeira linha da solicitação HTTP. |
| 24 | String getRequestedSessionId() Retorna o ID da sessão especificado pelo cliente. |
| 25 | String getServletPath() Retorna a parte da URL desta solicitação que chama o JSP. |
| 26 | String[] getParameterValues(String name) Retorna uma matriz de objetos String contendo todos os valores do parâmetro de solicitação fornecido ou nulo se o parâmetro não existir. |
| 27 | boolean isSecure() Retorna um booleano indicando se essa solicitação foi feita usando um canal seguro, como HTTPS. |
| 28 | int getContentLength() Retorna o comprimento, em bytes, do corpo da solicitação e disponibilizado pelo fluxo de entrada, ou -1 se o comprimento não for conhecido. |
| 29 | int getIntHeader(String name) Retorna o valor do cabeçalho da solicitação especificada como um int. |
| 30 | int getServerPort() Retorna o número da porta na qual esta solicitação foi recebida. |
Exemplo de solicitação de cabeçalho HTTP
A seguir está o exemplo que usa getHeaderNames()método de HttpServletRequest para ler as informações do cabeçalho HTTP. Este método retorna uma Enumeração que contém as informações do cabeçalho associadas à solicitação HTTP atual.
Assim que tivermos uma Enumeração, podemos fazer um loop para baixo da Enumeração da maneira padrão, usando o método hasMoreElements () para determinar quando parar e usando o método nextElement () para obter cada nome de parâmetro
// 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);
}
}Agora, chamar o servlet acima geraria o seguinte resultado -
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
Conforme discutido no capítulo anterior, quando um servidor Web responde a uma solicitação HTTP, a resposta normalmente consiste em uma linha de status, alguns cabeçalhos de resposta, uma linha em branco e o documento. Uma resposta típica fica assim -
HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
(Blank Line)
<!doctype ...>
<html>
<head>...</head>
<body>
...
</body>
</html>A linha de status consiste na versão HTTP (HTTP / 1.1 no exemplo), um código de status (200 no exemplo) e uma mensagem muito curta correspondente ao código de status (OK no exemplo).
A seguir está um resumo dos cabeçalhos de resposta HTTP 1.1 mais úteis que remontam ao navegador do lado do servidor da web e você os usaria com muita frequência na programação da web -
| Sr. Não. | Cabeçalho e Descrição |
|---|---|
| 1 | Allow Este cabeçalho especifica os métodos de solicitação (GET, POST, etc.) que o servidor suporta. |
| 2 | Cache-Control Este cabeçalho especifica as circunstâncias nas quais o documento de resposta pode ser armazenado em cache com segurança. Pode ter valorespublic, private ou no-cache etc. Público significa que o documento pode ser armazenado em cache, Privado significa que o documento é para um único usuário e só pode ser armazenado em caches privados (não compartilhados) e nocache significa que o documento nunca deve ser armazenado em cache. |
| 3 | Connection Este cabeçalho instrui o navegador se deve usar persistente em conexões HTTP ou não. Um valor declose instrui o navegador a não usar conexões HTTP persistentes e keepalive significa usar conexões persistentes. |
| 4 | Content-Disposition Este cabeçalho permite solicitar que o navegador peça ao usuário para salvar a resposta no disco em um arquivo com o nome fornecido. |
| 5 | Content-Encoding Este cabeçalho especifica a forma como a página foi codificada durante a transmissão. |
| 6 | Content-Language Este cabeçalho indica o idioma no qual o documento foi escrito. Por exemplo, en, en-us, ru, etc |
| 7 | Content-Length Este cabeçalho indica o número de bytes na resposta. Essas informações são necessárias apenas se o navegador estiver usando uma conexão HTTP persistente (keep-alive). |
| 8 | Content-Type Este cabeçalho fornece o tipo MIME (Multipurpose Internet Mail Extension) do documento de resposta. |
| 9 | Expires Este cabeçalho especifica a hora em que o conteúdo deve ser considerado desatualizado e, portanto, não deve mais ser armazenado em cache. |
| 10 | Last-Modified Este cabeçalho indica quando o documento foi alterado pela última vez. O cliente pode então armazenar em cache o documento e fornecer uma data por umIf-Modified-Since cabeçalho da solicitação em solicitações posteriores. |
| 11 | Location Esse cabeçalho deve ser incluído em todas as respostas que possuem um código de status na casa dos 300s. Isso notifica o navegador do endereço do documento. O navegador se reconecta automaticamente a este local e recupera o novo documento. |
| 12 | Refresh Este cabeçalho especifica em quanto tempo o navegador deve solicitar uma página atualizada. Você pode especificar o tempo em segundos após o qual uma página seria atualizada. |
| 13 | Retry-After Este cabeçalho pode ser usado em conjunto com uma resposta 503 (Serviço Indisponível) para informar ao cliente quando ele pode repetir sua solicitação. |
| 14 | Set-Cookie Este cabeçalho especifica um cookie associado à página. |
Métodos para definir o cabeçalho de resposta HTTP
Existem métodos a seguir que podem ser usados para definir o cabeçalho de resposta HTTP em seu programa de servlet. Esses métodos estão disponíveis com o objeto HttpServletResponse .
| Sr. Não. | Método e Descrição |
|---|---|
| 1 | String encodeRedirectURL(String url) Codifica o URL especificado para uso no método sendRedirect ou, se a codificação não for necessária, retorna o URL inalterado. |
| 2 | String encodeURL(String url) Codifica o URL especificado incluindo o ID da sessão nele ou, se a codificação não for necessária, retorna o URL inalterado. |
| 3 | boolean containsHeader(String name) Retorna um booleano indicando se o cabeçalho de resposta nomeado já foi definido. |
| 4 | boolean isCommitted() Retorna um booleano indicando se a resposta foi confirmada. |
| 5 | void addCookie(Cookie cookie) Adiciona o cookie especificado à resposta. |
| 6 | void addDateHeader(String name, long date) Adiciona um cabeçalho de resposta com o nome e valor de data fornecidos. |
| 7 | void addHeader(String name, String value) Adiciona um cabeçalho de resposta com o nome e valor fornecidos. |
| 8 | void addIntHeader(String name, int value) Adiciona um cabeçalho de resposta com o nome e valor inteiro fornecidos. |
| 9 | void flushBuffer() Força qualquer conteúdo do buffer a ser gravado no cliente. |
| 10 | void reset() Limpa todos os dados existentes no buffer, bem como o código de status e cabeçalhos. |
| 11 | void resetBuffer() Limpa o conteúdo do buffer subjacente na resposta sem limpar cabeçalhos ou código de status. |
| 12 | void sendError(int sc) Envia uma resposta de erro ao cliente usando o código de status especificado e limpando o buffer. |
| 13 | void sendError(int sc, String msg) Envia uma resposta de erro ao cliente usando o status especificado. |
| 14 | void sendRedirect(String location) Envia uma resposta de redirecionamento temporária ao cliente usando o URL do local de redirecionamento especificado. |
| 15 | void setBufferSize(int size) Define o tamanho do buffer preferido para o corpo da resposta. |
| 16 | void setCharacterEncoding(String charset) Define a codificação de caracteres (conjunto de caracteres MIME) da resposta enviada ao cliente, por exemplo, para UTF-8. |
| 17 | void setContentLength(int len) Define o comprimento do corpo do conteúdo na resposta. Em servlets HTTP, este método define o cabeçalho HTTP Content-Length. |
| 18 | void setContentType(String type) Define o tipo de conteúdo da resposta que está sendo enviada ao cliente, se a resposta ainda não foi confirmada. |
| 19 | void setDateHeader(String name, long date) Define um cabeçalho de resposta com o nome e valor de data fornecidos. |
| 20 | void setHeader(String name, String value) Define um cabeçalho de resposta com o nome e valor fornecidos. |
| 21 | void setIntHeader(String name, int value) Define um cabeçalho de resposta com o nome dado e valor inteiro |
| 22 | void setLocale(Locale loc) Define a localidade da resposta, se a resposta ainda não foi confirmada. |
| 23 | void setStatus(int sc) Define o código de status para esta resposta |
Exemplo de resposta de cabeçalho HTTP
Você já viu o método setContentType () funcionando nos exemplos anteriores e o exemplo a seguir também usaria o mesmo método, além disso, usaríamos setIntHeader() método para definir Refresh cabeçalho.
// 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);
}
}Agora, chamar o servlet acima exibiria a hora do sistema atual a cada 5 segundos, como segue. Basta executar o servlet e esperar para ver o resultado -
Auto Refresh Header Setting
Current Time is: 9:44:50 PM
O formato das mensagens de solicitação e resposta HTTP são semelhantes e terão a seguinte estrutura -
Uma linha de status inicial + CRLF (Retorno de carro + Alimentação de linha, ou seja, nova linha)
Zero ou mais linhas de cabeçalho + CRLF
Uma linha em branco, ou seja, um CRLF
Um corpo de mensagem opcional como arquivo, dados de consulta ou saída de consulta.
Por exemplo, um cabeçalho de resposta do servidor tem a seguinte aparência -
HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
(Blank Line)
<!doctype ...>
<html>
<head>...</head>
<body>
...
</body>
</html>A linha de status consiste na versão HTTP (HTTP / 1.1 no exemplo), um código de status (200 no exemplo) e uma mensagem muito curta correspondente ao código de status (OK no exemplo).
A seguir está uma lista de códigos de status HTTP e mensagens associadas que podem ser retornadas do servidor da Web -
| Código | mensagem | Descrição |
|---|---|---|
| 100 | Continuar | Apenas uma parte da solicitação foi recebida pelo servidor, mas desde que não tenha sido rejeitada, o cliente deve continuar com a solicitação |
| 101 | Protocolos de troca | O servidor muda de protocolo. |
| 200 | Está bem | O pedido está OK |
| 201 | Criada | A solicitação está concluída e um novo recurso é criado |
| 202 | Aceitaram | A solicitação foi aceita para processamento, mas o processamento não foi concluído. |
| 203 | Informação não oficial | |
| 204 | Sem conteúdo | |
| 205 | Redefinir conteúdo | |
| 206 | Conteúdo Parcial | |
| 300 | Escolhas múltiplas | Uma lista de links. O usuário pode selecionar um link e ir para aquele local. Máximo de cinco endereços |
| 301 | Movido Permanentemente | A página solicitada foi movida para um novo url |
| 302 | Encontrado | A página solicitada foi movida temporariamente para um novo url |
| 303 | Veja outro | A página solicitada pode ser encontrada em um url diferente |
| 304 | Não modificado | |
| 305 | Usar proxy | |
| 306 | Não utilizado | Este código foi usado em uma versão anterior. Não é mais usado, mas o código está reservado |
| 307 | Redirecionamento temporário | A página solicitada foi movida temporariamente para um novo url. |
| 400 | Pedido ruim | O servidor não entendeu o pedido |
| 401 | Não autorizado | A página solicitada precisa de um nome de usuário e uma senha |
| 402 | Pagamento Requerido | Você ainda não pode usar este código |
| 403 | Proibido | O acesso é proibido à página solicitada |
| 404 | Não encontrado | O servidor não pode encontrar a página solicitada. |
| 405 | Método não permitido | O método especificado na solicitação não é permitido. |
| 406 | Não aceitável | O servidor só pode gerar uma resposta que não seja aceita pelo cliente. |
| 407 | Autenticação proxy necessária | Você deve se autenticar com um servidor proxy antes que esta solicitação possa ser atendida. |
| 408 | Solicitar tempo limite | A solicitação demorou mais do que o servidor estava preparado para aguardar. |
| 409 | Conflito | A solicitação não pôde ser concluída devido a um conflito. |
| 410 | Se foi | A página solicitada não está mais disponível. |
| 411 | Comprimento Requerido | O "Content-Length" não está definido. O servidor não aceitará a solicitação sem ele. |
| 412 | A pré-condição falhou | A pré-condição fornecida na solicitação avaliada como falsa pelo servidor. |
| 413 | Solicitar Entidade Muito Grande | O servidor não aceitará a solicitação porque a entidade da solicitação é muito grande. |
| 414 | Request-url muito longo | O servidor não aceitará a solicitação porque o url é muito longo. Ocorre quando você converte uma solicitação "post" em uma solicitação "get" com uma longa informação de consulta. |
| 415 | Tipo de mídia não suportado | O servidor não aceitará a solicitação porque o tipo de mídia não é compatível. |
| 417 | A expectativa falhou | |
| 500 | Erro do Servidor Interno | O pedido não foi concluído. O servidor encontrou uma condição inesperada. |
| 501 | Não implementado | O pedido não foi concluído. O servidor não oferece suporte à funcionalidade necessária. |
| 502 | Gateway ruim | O pedido não foi concluído. O servidor recebeu uma resposta inválida do servidor upstream. |
| 503 | Serviço indisponível | O pedido não foi concluído. O servidor está temporariamente sobrecarregado ou inativo. |
| 504 | Tempo limite do gateway | O gateway atingiu o tempo limite. |
| 505 | Versão HTTP não suportada | O servidor não suporta a versão "protocolo http". |
Métodos para definir o código de status HTTP
Os métodos a seguir podem ser usados para definir o código de status HTTP em seu programa de servlet. Esses métodos estão disponíveis com o objeto HttpServletResponse .
| Sr. Não. | Método e Descrição |
|---|---|
| 1 | public void setStatus ( int statusCode ) Este método define um código de status arbitrário. O método setStatus aceita um int (o código de status) como argumento. Se sua resposta incluir um código de status especial e um documento, certifique-se de chamar setStatus antes de realmente retornar qualquer conteúdo com o PrintWriter . |
| 2 | public void sendRedirect(String url) Este método gera uma resposta 302 junto com um cabeçalho Location dando a URL do novo documento |
| 3 | public void sendError(int code, String message) Este método envia um código de status (geralmente 404) junto com uma mensagem curta que é formatada automaticamente dentro de um documento HTML e enviada ao cliente. |
Exemplo de código de status HTTP
A seguir está o exemplo que enviaria um código de erro 407 para o navegador do cliente e o navegador mostraria "Necessita de autenticação !!!" mensagem.
// 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);
}
}Agora, chamar o servlet acima exibiria o seguinte resultado -
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
Filtros de servlet são classes Java que podem ser usadas na programação de servlet para os seguintes propósitos -
Para interceptar solicitações de um cliente antes que eles acessem um recurso no back end.
Para manipular as respostas do servidor antes de serem enviadas de volta ao cliente.
Existem vários tipos de filtros sugeridos pelas especificações -
- Filtros de autenticação.
- Filtros de compressão de dados.
- Filtros de criptografia.
- Filtros que acionam eventos de acesso a recursos.
- Filtros de conversão de imagem.
- Filtros de registro e auditoria.
- Filtros de cadeia do tipo MIME.
- Filtros de tokenização.
- Filtros XSL / T que transformam conteúdo XML.
Os filtros são implantados no arquivo descritor de implantação web.xml e, em seguida, mapeie para nomes de servlet ou padrões de URL no descritor de implantação de seu aplicativo.
Quando o contêiner da web inicia seu aplicativo da web, ele cria uma instância de cada filtro que você declarou no descritor de implantação. Os filtros são executados na ordem em que são declarados no descritor de implantação.
Métodos de filtro de servlet
Um filtro é simplesmente uma classe Java que implementa a interface javax.servlet.Filter. A interface javax.servlet.Filter define três métodos -
| Sr. Não. | Método e Descrição |
|---|---|
| 1 | public void doFilter (ServletRequest, ServletResponse, FilterChain) Este método é chamado pelo contêiner cada vez que um par de solicitação / resposta é passado pela cadeia devido a uma solicitação do cliente por um recurso no final da cadeia. |
| 2 | public void init(FilterConfig filterConfig) Este método é chamado pelo contêiner da web para indicar a um filtro que ele está sendo colocado em serviço. |
| 3 | public void destroy() Este método é chamado pelo contêiner da web para indicar a um filtro que ele está sendo retirado de serviço. |
Filtro de servlet - exemplo
A seguir está o Exemplo de Filtro de Servlet que imprimiria o endereço IP do cliente e a data e hora atual. Este exemplo daria a você uma compreensão básica do Filtro de Servlet, mas você pode escrever aplicativos de filtro mais sofisticados usando o mesmo conceito -
// 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*/
}
}Compilar LogFilter.java da maneira usual e coloque seu arquivo de classe em <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes
Mapeamento de filtro de servlet em Web.xml
Os filtros são definidos e, em seguida, mapeados para um URL ou Servlet, da mesma forma que o Servlet é definido e, em seguida, mapeado para um padrão de URL. Crie a seguinte entrada para a tag de filtro no arquivo descritor de implantaçãoweb.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>O filtro acima se aplicaria a todos os servlets porque especificamos /*em nossa configuração. Você pode especificar um caminho de servlet específico se quiser aplicar o filtro apenas em alguns servlets.
Agora tente chamar qualquer servlet da maneira usual e você verá o log gerado no log do seu servidor web. Você pode usar o logger Log4J para registrar o log acima em um arquivo separado.
Usando vários filtros
Seu aplicativo da web pode definir vários filtros diferentes com uma finalidade específica. Considere, você define dois filtros AuthenFilter e LogFilter . O resto do processo permaneceria conforme explicado acima, exceto que você precisa criar um mapeamento diferente, conforme mencionado abaixo -
<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>Ordem de aplicação de filtros
A ordem dos elementos de mapeamento de filtro em web.xml determina a ordem em que o contêiner da web aplica o filtro ao servlet. Para reverter a ordem do filtro, você só precisa reverter os elementos de mapeamento de filtro no arquivo web.xml.
Por exemplo, o exemplo acima aplicaria LogFilter primeiro e, em seguida, aplicaria AuthenFilter a qualquer servlet, mas o exemplo a seguir inverteria a ordem -
<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 um servlet lança uma exceção, o contêiner da web procura as configurações em web.xml que usam o elemento de tipo de exceção para uma correspondência com o tipo de exceção lançada.
Você teria que usar o error-page elemento em web.xml para especificar a invocação de servlets em resposta a certos exceptions ou HTTP status codes.
Configuração web.xml
Considere que você tem um servlet ErrorHandler que seria chamado sempre que houvesse qualquer exceção ou erro definido. A seguir está a entrada criada em 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 você deseja ter um manipulador de erro genérico para todas as exceções, você deve definir a seguinte página de erro em vez de definir elementos separados da página de erro para cada exceção -
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>A seguir estão os pontos a serem observados sobre o web.xml acima para Tratamento de Exceções -
O servlet ErrorHandler é definido da maneira usual como qualquer outro servlet e configurado em web.xml.
Se houver algum erro com o código de status 404 (Não encontrado) ou 403 (Proibido), o servlet ErrorHandler será chamado.
Se o aplicativo da web lançar ServletException ou IOException, o contêiner da web invocará o servlet / ErrorHandler.
Você pode definir diferentes Manipuladores de Erro para lidar com diferentes tipos de erros ou exceções. O exemplo acima é muito genérico e espero que sirva ao propósito de explicar o conceito básico.
Solicitar Atributos - Erros / Exceções
A seguir está a lista de atributos de solicitação que um servlet de tratamento de erros pode acessar para analisar a natureza do erro / exceção.
| Sr. Não. | Atributo e descrição |
|---|---|
| 1 | javax.servlet.error.status_code Este atributo fornece código de status que pode ser armazenado e analisado após o armazenamento em um tipo de dados java.lang.Integer. |
| 2 | javax.servlet.error.exception_type Este atributo fornece informações sobre o tipo de exceção que pode ser armazenado e analisado após o armazenamento em um tipo de dados java.lang.Class. |
| 3 | javax.servlet.error.message Este atributo fornece informações de mensagens de erro exatas que podem ser armazenadas e analisadas após o armazenamento em um tipo de dados java.lang.String. |
| 4 | javax.servlet.error.request_uri Este atributo fornece informações sobre a URL que chama o servlet e pode ser armazenado e analisado após o armazenamento em um tipo de dados java.lang.String. |
| 5 | javax.servlet.error.exception Este atributo fornece informações sobre a exceção levantada, que pode ser armazenada e analisada. |
| 6 | javax.servlet.error.servlet_name Este atributo fornece o nome do servlet que pode ser armazenado e analisado após o armazenamento em um tipo de dados java.lang.String. |
Exemplo de servlet manipulador de erros
Este exemplo daria a você uma compreensão básica do Tratamento de Exceções no Servlet, mas você pode escrever aplicativos de filtro mais sofisticados usando o mesmo conceito -
// 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);
}
}Compilar ErrorHandler.java da maneira usual e coloque seu arquivo de classe em
Vamos adicionar a seguinte configuração em web.xml para lidar com exceções -
<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>Agora tente usar um servlet que levanta qualquer exceção ou digite um URL errado, isso acionaria o Web Container para chamar ErrorHandlerservlet e exibir uma mensagem apropriada conforme programado. Por exemplo, se você digitar um URL errado, ele exibirá o seguinte resultado -
The status code : 404O código acima pode não funcionar com alguns navegadores da web. Portanto, tente com Mozilla e Safari e deve funcionar.
Cookies são arquivos de texto armazenados no computador cliente e são mantidos para diversos fins de rastreamento de informações. Java Servlets suporta cookies HTTP de forma transparente.
Existem três etapas envolvidas na identificação de usuários recorrentes -
O script de servidor envia um conjunto de cookies para o navegador. Por exemplo, nome, idade ou número de identificação etc.
O navegador armazena essas informações na máquina local para uso futuro.
Na próxima vez que o navegador enviar qualquer solicitação ao servidor web, ele enviará as informações dos cookies para o servidor e o servidor usará essas informações para identificar o usuário.
Este capítulo irá ensiná-lo como definir ou redefinir cookies, como acessá-los e como excluí-los.
A anatomia de um biscoito
Os cookies são geralmente definidos em um cabeçalho HTTP (embora o JavaScript também possa definir um cookie diretamente em um navegador). Um servlet que define um cookie pode enviar cabeçalhos parecidos com este -
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/htmlComo você pode ver, o cabeçalho Set-Cookie contém um par nome-valor, uma data GMT, um caminho e um domínio. O nome e o valor serão codificados por URL. O campo expira é uma instrução para o navegador "esquecer" o cookie após a data e hora fornecidas.
Se o navegador estiver configurado para armazenar cookies, ele manterá essas informações até a data de expiração. Se o usuário apontar o navegador para qualquer página que corresponda ao caminho e domínio do cookie, ele reenviará o cookie ao servidor. Os cabeçalhos do navegador podem ser parecidos com isto -
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 = xyzUm servlet terá então acesso ao cookie por meio do método de solicitação request.getCookies () que retorna uma matriz de objetos Cookie .
Métodos de cookies servlet
A seguir está a lista de métodos úteis que você pode usar ao manipular cookies no servlet.
| Sr. Não. | Método e Descrição |
|---|---|
| 1 | public void setDomain(String pattern) Este método define o domínio ao qual o cookie se aplica, por exemplo tutorialspoint.com. |
| 2 | public String getDomain() Este método obtém o domínio ao qual o cookie se aplica, por exemplo tutorialspoint.com. |
| 3 | public void setMaxAge(int expiry) Este método define quanto tempo (em segundos) deve decorrer antes que o cookie expire. Se você não definir isso, o cookie durará apenas a sessão atual. |
| 4 | public int getMaxAge() Este método retorna a idade máxima do cookie, especificada em segundos, por padrão, -1 indicando que o cookie irá persistir até o desligamento do navegador. |
| 5 | public String getName() Este método retorna o nome do cookie. O nome não pode ser alterado após a criação. |
| 6 | public void setValue(String newValue) Este método define o valor associado ao cookie |
| 7 | public String getValue() Este método obtém o valor associado ao cookie. |
| 8 | public void setPath(String uri) Este método define o caminho ao qual este cookie se aplica. Se você não especificar um caminho, o cookie será retornado para todos os URLs no mesmo diretório da página atual, bem como para todos os subdiretórios. |
| 9 | public String getPath() Este método obtém o caminho ao qual este cookie se aplica. |
| 10 | public void setSecure(boolean flag) Este método define o valor booleano que indica se o cookie deve ser enviado apenas por conexões criptografadas (ou seja, SSL). |
| 11 | public void setComment(String purpose) Este método especifica um comentário que descreve a finalidade de um cookie. O comentário é útil se o navegador apresentar o cookie ao usuário. |
| 12 | public String getComment() Este método retorna o comentário que descreve a finalidade deste cookie, ou null se o cookie não tiver comentários. |
Configurando Cookies com Servlet
Definir cookies com servlet envolve três etapas -
(1) Creating a Cookie object - Você chama o construtor Cookie com um nome de cookie e um valor de cookie, sendo que ambos são strings.
Cookie cookie = new Cookie("key","value");Lembre-se de que nem o nome nem o valor devem conter espaço em branco ou qualquer um dos seguintes caracteres -
[ ] ( ) = , " / ? @ : ;(2) Setting the maximum age- Use setMaxAge para especificar por quanto tempo (em segundos) o cookie deve ser válido. A seguir configuraria um cookie por 24 horas.
cookie.setMaxAge(60 * 60 * 24);(3) Sending the Cookie into the HTTP response headers - Use response.addCookie para adicionar cookies no cabeçalho de resposta HTTP da seguinte maneira -
response.addCookie(cookie);Exemplo
Vamos modificar nosso exemplo de formulário para definir os cookies para o nome e o sobrenome.
// 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>"
);
}
}Compile o servlet acima HelloForm e crie a entrada apropriada no arquivo web.xml e, finalmente, tente seguir a página HTML para chamar o 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>Mantenha o conteúdo HTML acima em um arquivo Hello.htm e coloque-o no diretório <Tomcat-installationdirectory> / webapps / ROOT. Quando você acessa http: // localhost: 8080 / Hello.htm , aqui está a saída real do formulário acima.
Tente inserir o nome e o sobrenome e clique no botão enviar. Isso exibiria o nome e o sobrenome na tela e, ao mesmo tempo, definiria dois cookies firstName e lastName, que seriam passados de volta para o servidor na próxima vez em que você pressionasse o botão Enviar.
A próxima seção explicaria como você acessaria esses cookies em seu aplicativo da web.
Lendo Cookies com Servlet
Para ler cookies, você precisa criar uma matriz de objetos javax.servlet.http.Cookie chamando ogetCookies()método de HttpServletRequest . Em seguida, percorra o array e use os métodos getName () e getValue () para acessar cada cookie e valor associado.
Exemplo
Vamos ler os cookies que definimos no exemplo anterior -
// 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>");
}
}Compilar o servlet acima ReadCookiese crie a entrada apropriada no arquivo web.xml. Se você tivesse definido o cookie first_name como "John" e o cookie last_name como "Player", executar http: // localhost: 8080 / ReadCookies exibiria o seguinte resultado -
Found Cookies Name and Value
Name : first_name, Value: John
Name : last_name, Value: PlayerApagar Cookies com Servlet
Excluir cookies é muito simples. Se você deseja excluir um cookie, basta seguir as três etapas seguintes -
Leia um cookie já existente e armazene-o no objeto Cookie.
Defina a idade do cookie como zero usando setMaxAge() método para excluir um cookie existente
Adicione este cookie de volta ao cabeçalho da resposta.
Exemplo
O exemplo a seguir excluiria um cookie existente denominado "first_name" e quando você executasse o servlet ReadCookies na próxima vez, ele retornaria um valor nulo para 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>");
}
}Compilar o servlet acima DeleteCookiese crie a entrada apropriada no arquivo web.xml. Agora, executando http: // localhost: 8080 / DeleteCookies exibiria o seguinte resultado -
Cookies Name and Value
Deleted cookie : first_name
Name : first_name, Value: John
Name : last_name, Value: Player
Agora tente executar http: // localhost: 8080 / ReadCookies e ele exibirá apenas um cookie da seguinte forma -
Found Cookies Name and Value
Name : last_name, Value: PlayerVocê pode excluir seus cookies no Internet Explorer manualmente. Comece no menu Ferramentas e selecione Opções da Internet. Para excluir todos os cookies, pressione Excluir Cookies.
HTTP é um protocolo "sem estado", o que significa que cada vez que um cliente recupera uma página da Web, o cliente abre uma conexão separada com o servidor da Web e o servidor automaticamente não mantém nenhum registro da solicitação anterior do cliente.
Ainda assim, existem três maneiras de manter a sessão entre o cliente da web e o servidor da web -
Biscoitos
Um servidor da web pode atribuir um ID de sessão único como um cookie para cada cliente da web e para solicitações subsequentes do cliente, eles podem ser reconhecidos usando o cookie recebido.
Esta pode não ser uma maneira eficaz porque muitas vezes o navegador não suporta um cookie, então eu não recomendo usar este procedimento para manter as sessões.
Campos de formulário ocultos
Um servidor da web pode enviar um campo de formulário HTML oculto junto com um ID de sessão exclusivo da seguinte maneira -
<input type = "hidden" name = "sessionid" value = "12345">Esta entrada significa que, quando o formulário é enviado, o nome e o valor especificados são incluídos automaticamente nos dados GET ou POST. Cada vez que o navegador da web envia a solicitação de volta, o valor session_id pode ser usado para manter o controle de diferentes navegadores da web.
Esta poderia ser uma forma eficaz de controlar a sessão, mas clicar em um link de hipertexto normal (<A HREF...>) não resulta no envio do formulário, portanto, os campos ocultos do formulário também não podem oferecer suporte ao rastreamento geral da sessão.
Reescrita de URL
Você pode anexar alguns dados extras no final de cada URL que identifica a sessão, e o servidor pode associar esse identificador de sessão aos dados que ele armazenou sobre essa sessão.
Por exemplo, com http://tutorialspoint.com/file.htm;sessionid = 12345, o identificador de sessão é anexado como sessionid = 12345 que pode ser acessado no servidor da web para identificar o cliente.
A regravação de URL é a melhor maneira de manter as sessões e funciona mesmo quando os navegadores não oferecem suporte a cookies. A desvantagem da reescrita de URL é que você teria que gerar cada URL dinamicamente para atribuir um ID de sessão, mesmo no caso de uma página HTML estática simples.
O objeto HttpSession
Além das três maneiras mencionadas acima, o servlet fornece HttpSession Interface, que fornece uma maneira de identificar um usuário em mais de uma solicitação de página ou visita a um site da Web e para armazenar informações sobre esse usuário.
O contêiner de servlet usa essa interface para criar uma sessão entre um cliente HTTP e um servidor HTTP. A sessão persiste por um período de tempo especificado, em mais de uma conexão ou solicitação de página do usuário.
Você obteria o objeto HttpSession chamando o método público getSession() de HttpServletRequest, conforme abaixo -
HttpSession session = request.getSession();Você precisa chamar request.getSession () antes de enviar qualquer conteúdo de documento ao cliente. Aqui está um resumo dos métodos importantes disponíveis por meio do objeto HttpSession -
| Sr. Não. | Método e Descrição |
|---|---|
| 1 | public Object getAttribute(String name) Este método retorna o objeto vinculado ao nome especificado nesta sessão ou nulo se nenhum objeto estiver vinculado ao nome. |
| 2 | public Enumeration getAttributeNames() Este método retorna uma Enumeração de objetos String contendo os nomes de todos os objetos vinculados a esta sessão. |
| 3 | public long getCreationTime() Este método retorna a hora em que esta sessão foi criada, medida em milissegundos desde a meia-noite de 1º de janeiro de 1970 GMT. |
| 4 | public String getId() Este método retorna uma string contendo o identificador exclusivo atribuído a esta sessão. |
| 5 | public long getLastAccessedTime() Este método retorna a hora do último acesso da sessão, no formato de milissegundos desde a meia-noite de 1º de janeiro de 1970 GMT |
| 6 | public int getMaxInactiveInterval() Este método retorna o intervalo de tempo máximo (segundos), que o container do servlet manterá a sessão aberta entre os acessos do cliente. |
| 7 | public void invalidate() Este método invalida esta sessão e desassocia todos os objetos ligados a ela. |
| 8 | public boolean isNew( Este método retorna verdadeiro se o cliente ainda não sabe sobre a sessão ou se o cliente escolhe não ingressar na sessão. |
| 9 | public void removeAttribute(String name) Este método remove o objeto vinculado ao nome especificado desta sessão. |
| 10 | public void setAttribute(String name, Object value) Este método liga um objeto a esta sessão, usando o nome especificado. |
| 11 | public void setMaxInactiveInterval(int interval) Este método especifica o tempo, em segundos, entre as solicitações do cliente antes que o contêiner do servlet invalide esta sessão. |
Exemplo de rastreamento de sessão
Este exemplo descreve como usar o objeto HttpSession para descobrir a hora de criação e a hora do último acesso de uma sessão. Gostaríamos de associar uma nova sessão ao pedido, se ainda não existir.
// 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>"
);
}
}Compile o servlet acima SessionTracke crie a entrada apropriada no arquivo web.xml. Agora, executando http: // localhost: 8080 / SessionTrack exibiria o seguinte resultado quando você executasse pela primeira vez -
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
Agora tente executar o mesmo servlet pela segunda vez, ele exibirá o seguinte resultado.
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
Excluindo Dados da Sessão
Ao terminar com os dados de sessão de um usuário, você tem várias opções -
Remove a particular attribute- Você pode chamar o método public void removeAttribute (String name) para excluir o valor associado a uma chave específica.
Delete the whole session- Você pode chamar o método void invalidate () público para descartar uma sessão inteira.
Setting Session timeout- Você pode chamar o método public void setMaxInactiveInterval (int interval) para definir o tempo limite de uma sessão individualmente.
Log the user out - Os servidores que suportam servlets 2.4, você pode chamar logout para desconectar o cliente do servidor Web e invalidar todas as sessões pertencentes a todos os usuários.
web.xml Configuration - Se você estiver usando o Tomcat, além dos métodos mencionados acima, você pode configurar o tempo limite da sessão no arquivo web.xml da seguinte maneira.
<session-config>
<session-timeout>15</session-timeout>
</session-config>O tempo limite é expresso em minutos e substitui o tempo limite padrão, que é de 30 minutos no Tomcat.
O método getMaxInactiveInterval () em um servlet retorna o período de tempo limite para aquela sessão em segundos. Portanto, se sua sessão for configurada em web.xml por 15 minutos, getMaxInactiveInterval () retornará 900.
Este tutorial presume que você tenha conhecimento de como o aplicativo JDBC funciona. Antes de iniciar o acesso ao banco de dados por meio de um servlet, certifique-se de ter configurado o ambiente JDBC adequado junto com um banco de dados.
Para obter mais detalhes sobre como acessar o banco de dados usando JDBC e sua configuração de ambiente, você pode consultar nosso Tutorial JDBC .
Para começar com o conceito básico, vamos criar uma tabela simples e criar alguns registros nessa tabela da seguinte forma -
Criar a tabela
Para criar o Employees tabela no banco de dados TEST, use as seguintes etapas -
Passo 1
Abra um Command Prompt e mude para o diretório de instalação da seguinte forma -
C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>Passo 2
Faça login no banco de dados como segue
C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>etapa 3
Crie a mesa Employee dentro TEST banco de dados da seguinte forma -
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>Criar registros de dados
Finalmente, você cria alguns registros na tabela Employee da seguinte forma -
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>Acessando um banco de dados
Aqui está um exemplo que mostra como acessar o banco de dados TEST usando 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
}
}Agora vamos compilar o servlet acima e criar as seguintes entradas em 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>
....Agora chame este servlet usando o URL http: // localhost: 8080 / DatabaseAccess que exibiria a seguinte resposta -
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: MittalUm Servlet pode ser usado com uma tag de formulário HTML para permitir que os usuários carreguem arquivos para o servidor. Um arquivo carregado pode ser um arquivo de texto ou arquivo de imagem ou qualquer documento.
Criação de um formulário de upload de arquivo
O seguinte código HTM abaixo cria um formulário de upload. A seguir estão os pontos importantes a serem anotados -
A forma method atributo deve ser definido como POST método e método GET não podem ser usados
A forma enctype atributo deve ser definido como multipart/form-data.
A forma actionatributo deve ser definido como um arquivo servlet que manipularia o upload de arquivos no servidor backend. O exemplo a seguir está usandoUploadServlet servlet para fazer upload do arquivo.
Para fazer upload de um único arquivo, você deve usar uma única tag <input ... /> com o atributo type = "file". Para permitir o upload de vários arquivos, inclua mais de uma tag de entrada com valores diferentes para o atributo name. O navegador associa um botão Procurar a cada um deles.
<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>Isso exibirá o seguinte resultado que permitiria selecionar um arquivo do PC local e quando o usuário clicar em "Carregar arquivo", o formulário será enviado junto com o arquivo selecionado -
File Upload:
Select a file to upload:
NOTE: This is just dummy form and would not work.Escrevendo Servlet Backend
A seguir está o servlet UploadServletque se encarregaria de aceitar o arquivo carregado e armazená-lo no diretório <Tomcat-installation-directory> / webapps / data. Este nome de diretório também pode ser adicionado usando uma configuração externa, como umcontext-param elemento em web.xml da seguinte forma -
<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>A seguir está o código-fonte para UploadServlet, que pode lidar com o upload de vários arquivos ao mesmo tempo. Antes de continuar, certifique-se de que o seguinte -
O exemplo a seguir depende de FileUpload, portanto, certifique-se de ter a versão mais recente do commons-fileupload.x.x.jararquivo em seu classpath. Você pode baixá-lo dehttps://commons.apache.org/fileupload/.
FileUpload depende do Commons IO, então certifique-se de ter a versão mais recente do commons-io-x.x.jararquivo em seu classpath. Você pode baixá-lo dehttps://commons.apache.org/io/.
Ao testar o exemplo a seguir, você deve carregar um arquivo que tenha menos tamanho que maxFileSize, caso contrário, o arquivo não será carregado.
Certifique-se de ter criado os diretórios c: \ temp e c: \ apache-tomcat8.0.28 \ webapps \ data com bastante antecedência.
// 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.");
}
}
}Compilar e executar o servlet
Compile o servlet UploadServlet acima e crie a entrada necessária no arquivo web.xml conforme a seguir.
<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>Agora tente fazer upload de arquivos usando o formulário HTML que você criou acima. Quando você tentava http: // localhost: 8080 / UploadFile.htm, ele exibia o seguinte resultado que o ajudaria a enviar qualquer arquivo de sua máquina local.
File Upload:
Select a file to upload:
Se o script do servlet funcionar bem, o arquivo deve ser carregado no diretório c: \ apache-tomcat8.0.28 \ webapps \ data \.
Uma das vantagens mais importantes de usar Servlet é que você pode usar a maioria dos métodos disponíveis no núcleo do Java. Este tutorial o levará através do Java fornecidoDate classe que está disponível em java.util pacote, esta classe encapsula a data e hora atuais.
A classe Date oferece suporte a dois construtores. O primeiro construtor inicializa o objeto com a data e hora atuais.
Date( )O construtor a seguir aceita um argumento que é igual ao número de milissegundos decorridos desde a meia-noite de 1º de janeiro de 1970
Date(long millisec)Depois de ter um objeto Date disponível, você pode chamar qualquer um dos seguintes métodos de suporte para brincar com datas -
| Sr. Não. | Métodos e Descrição |
|---|---|
| 1 | boolean after(Date date) Retorna verdadeiro se o objeto de chamada Date contiver uma data posterior à especificada por data; caso contrário, retorna falso. |
| 2 | boolean before(Date date) Retorna verdadeiro se o objeto Date de chamada contiver uma data anterior à especificada por data; caso contrário, retorna falso. |
| 3 | Object clone( ) Duplica o objeto Date de chamada. |
| 4 | int compareTo(Date date) Compara o valor do objeto de chamada com o de data. Retorna 0 se os valores forem iguais. Retorna um valor negativo se o objeto de chamada for anterior à data. Retorna um valor positivo se o objeto de chamada for posterior à data. |
| 5 | int compareTo(Object obj) Opera de forma idêntica a compareTo (Date) se obj for da classe Date. Caso contrário, ele lança uma ClassCastException. |
| 6 | boolean equals(Object date) Retorna verdadeiro se o objeto de invocação Date contém a mesma hora e data que aquele especificado por data; caso contrário, retorna falso. |
| 7 | long getTime( ) Retorna o número de milissegundos decorridos desde 1º de janeiro de 1970. |
| 8 | int hashCode( ) Retorna um código hash para o objeto de chamada. |
| 9 | void setTime(long time) Define a hora e a data conforme especificado por time, que representa um tempo decorrido em milissegundos a partir da meia-noite de 1º de janeiro de 1970. |
| 10 | String toString( ) Converte o objeto de chamada Date em uma string e retorna o resultado. |
Obtendo data e hora atuais
É muito fácil obter a data e a hora atuais no Java Servlet. Você pode usar um objeto Date simples com o método toString () para imprimir a data e hora atuais da seguinte maneira -
// 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>"
);
}
}Agora, vamos compilar o servlet acima e criar entradas apropriadas em web.xml e, em seguida, chamar esse servlet usando a URL http: // localhost: 8080 / CurrentDate. Isso produziria o seguinte resultado -
Display Current Date & Time
Mon Jun 21 21:46:49 GMT+04:00 2010
Tente atualizar o URL http: // localhost: 8080 / CurrentDate e você encontrará a diferença em segundos sempre que fizer a atualização.
Comparação de datas
Como mencionei acima, você pode usar todos os métodos Java disponíveis em seu Servlet. Caso você precise comparar duas datas, a seguir estão os métodos -
Você pode usar getTime () para obter o número de milissegundos decorridos desde a meia-noite de 1º de janeiro de 1970 para ambos os objetos e, em seguida, comparar esses dois valores.
Você pode usar os métodos before (), after () e equals (). Como o 12º dia do mês vem antes do 18º, por exemplo, new Date (99, 2, 12) .before (new Date (99, 2, 18)) retorna true.
Você pode usar o método compareTo (), que é definido pela interface Comparable e implementado por Date.
Formatação de data usando SimpleDateFormat
SimpleDateFormat é uma classe concreta para formatar e analisar datas de maneira sensível ao local. SimpleDateFormat permite que você comece escolhendo quaisquer padrões definidos pelo usuário para a formatação de data e hora.
Vamos modificar o exemplo acima da seguinte maneira -
// 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>"
);
}
}Compile o servlet acima mais uma vez e, em seguida, chame esse servlet usando a URL http: // localhost: 8080 / CurrentDate. Isso produziria o seguinte resultado -
Display Current Date & Time
Mon 2010.06.21 at 10:06:44 PM GMT+04:00
Códigos de formato simples de DateFormat
Para especificar o formato da hora, use uma string de padrão de hora. Neste padrão, todas as letras ASCII são reservadas como letras padrão, que são definidas da seguinte forma -
| Personagem | Descrição | Exemplo |
|---|---|---|
| G | Designador era | DE ANÚNCIOS |
| y | Ano em quatro dígitos | 2001 |
| M | Mês no ano | Julho ou 07 |
| d | Dia no mês | 10 |
| h | Hora em AM / PM (1 ~ 12) | 12 |
| H | Hora do dia (0 ~ 23) | 22 |
| m | Minuto em hora | 30 |
| s | Segundo em minuto | 55 |
| S | Milissegundo | 234 |
| E | Dia da semana | terça |
| D | Dia no ano | 360 |
| F | Dia da semana no mês | 2 (segunda quarta-feira em julho) |
| W | Semana no ano | 40 |
| W | Semana no mês | 1 |
| uma | Marcador AM / PM | PM |
| k | Hora do dia (1 ~ 24) | 24 |
| K | Hora em AM / PM (0 ~ 11) | 10 |
| z | Fuso horário | Hora Padrão do Leste |
| ' | Escape para texto | Delimitador |
| " | Citação única | ` |
Para uma lista completa de métodos constantes disponíveis para manipular data, você pode consultar a documentação Java padrão.
O redirecionamento de página é uma técnica em que o cliente é enviado para um novo local diferente do solicitado. O redirecionamento de página geralmente é usado quando um documento é movido para um novo local ou pode ser devido ao balanceamento de carga.
A maneira mais simples de redirecionar uma solicitação para outra página é usando o método sendRedirect()do objeto de resposta. A seguir está a assinatura deste método -
public void HttpServletResponse.sendRedirect(String location)
throws IOExceptionEste método envia de volta a resposta ao navegador junto com o código de status e o novo local da página. Você também pode usar os métodos setStatus () e setHeader () juntos para obter o mesmo -
....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
....Exemplo
Este exemplo mostra como um servlet executa o redirecionamento de página para outro local -
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);
}
}Agora vamos compilar o servlet acima e criar as seguintes entradas em 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>
....Agora chame esse servlet usando o URL http: // localhost: 8080 / PageRedirect. Isso redirecionaria você para o URL http://www.photofuntoos.com.
Hit Counter para uma página da web
Muitas vezes você estaria interessado em saber o número total de acessos em uma página específica do seu site. É muito simples contar essas ocorrências usando um servlet porque o ciclo de vida de um servlet é controlado pelo contêiner no qual ele é executado.
A seguir estão as etapas a serem seguidas para implementar um contador de visitas de página simples que é baseado no Ciclo de Vida do Servlet -
Inicialize uma variável global no método init ().
Aumente a variável global sempre que o método doGet () ou doPost () for chamado.
Se necessário, você pode usar uma tabela de banco de dados para armazenar o valor da variável global no método destroy (). Este valor pode ser lido dentro do método init () quando o servlet for inicializado na próxima vez. Esta etapa é opcional.
Se você deseja contar apenas hits de página únicos em uma sessão, você pode usar o método isNew () para verificar se a mesma página já foi atingida nessa sessão. Esta etapa é opcional.
Você pode exibir o valor do contador global para mostrar o número total de acessos em seu site. Esta etapa também é opcional.
Aqui, estou assumindo que o contêiner da web não será reiniciado. Se ele for reiniciado ou o servlet destruído, o contador de visitas será zerado.
Exemplo
Este exemplo mostra como implementar um contador de visitas de página simples -
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.
}
}Agora vamos compilar o servlet acima e criar as seguintes entradas em 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>
....Agora chame esse servlet usando o URL http: // localhost: 8080 / PageHitCounter. Isso aumentaria o contador em um cada vez que esta página fosse atualizada e mostraria o seguinte resultado -
Total Number of Hits
6
Hit Counter for a Website:
Muitas vezes você estaria interessado em saber o número total de acessos em todo o seu site. Isso também é muito simples no Servlet e podemos fazer isso usando filtros.
A seguir estão as etapas a serem seguidas para implementar um contador de visitas simples de um site baseado no Ciclo de Vida do Filtro -
Inicialize uma variável global no método init () de um filtro.
Aumente a variável global sempre que o método doFilter for chamado.
Se necessário, você pode usar uma tabela de banco de dados para armazenar o valor da variável global no método de filtro destroy (). Este valor pode ser lido dentro do método init () quando o filtro for inicializado na próxima vez. Esta etapa é opcional.
Aqui, estou assumindo que o contêiner da web não será reiniciado. Se ele for reiniciado ou o servlet destruído, o contador de visitas será zerado.
Exemplo
Este exemplo mostra como implementar um contador de visitas de site simples -
// 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.
}
}Agora vamos compilar o servlet acima e criar as seguintes entradas em 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>
....Agora chame qualquer URL como http: // localhost: 8080 /. Isso aumentaria o contador em um cada vez que qualquer página fosse acessada e seria exibida a seguinte mensagem no log -
Site visits count : 1
Site visits count : 2
Site visits count : 3
Site visits count : 4
Site visits count : 5
..................Considere uma página da Web que exibe o placar do jogo ao vivo, o status do mercado de ações ou a taxa de câmbio. Para todos esses tipos de páginas, você precisa atualizar sua página da web regularmente usando o botão atualizar ou recarregar do navegador.
O Java Servlet facilita esse trabalho, fornecendo a você um mecanismo onde você pode criar uma página da Web de forma que ela seja atualizada automaticamente após um determinado intervalo.
A maneira mais simples de atualizar uma página da web é usar o método setIntHeader()do objeto de resposta. A seguir está a assinatura deste método -
public void setIntHeader(String header, int headerValue)Este método envia de volta o cabeçalho "Atualizar" para o navegador junto com um valor inteiro que indica o intervalo de tempo em segundos.
Exemplo de atualização automática de página
Este exemplo mostra como um servlet executa a atualização automática da página usando setIntHeader() método para definir Refresh cabeçalho.
// 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);
}
}Agora vamos compilar o servlet acima e criar as seguintes entradas em 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>
....Agora chame esse servlet usando a URL http: // localhost: 8080 / Refresh, que exibiria a hora atual do sistema a cada 5 segundos, conforme a seguir. Basta executar o servlet e esperar para ver o resultado -
Auto Page Refresh using Servlet
Current Time is: 9:44:50 PM
Para enviar um e-mail usando o seu Servlet é simples o suficiente, mas para começar você deve ter JavaMail API e Java Activation Framework (JAF) instalado em sua máquina.
Você pode baixar a versão mais recente do JavaMail (versão 1.2) do site padrão do Java.
Você pode baixar a versão mais recente do JAF (Versão 1.1.1) do site padrão do Java.
Baixe e descompacte esses arquivos. Nos diretórios de nível superior recém-criados, você encontrará vários arquivos jar para ambos os aplicativos. Você precisa adicionarmail.jar e activation.jar arquivos em seu CLASSPATH.
Envie um e-mail simples
Aqui está um exemplo para enviar um e-mail simples de sua máquina. Aqui, presume-se que seulocalhostestá conectado à Internet e é capaz de enviar um e-mail. Ao mesmo tempo, certifique-se de que todos os arquivos jar do pacote Java Email API e JAF estejam disponíveis em 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();
}
}
}Agora vamos compilar o servlet acima e criar as seguintes entradas em 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>
....Agora chame este servlet usando o URL http: // localhost: 8080 / SendEmail que enviaria um e-mail para o ID de e- mail fornecido [email protected] e exibiria a seguinte resposta -
Send Email
Sent message successfully....
Se você deseja enviar um e-mail para vários destinatários, os seguintes métodos devem ser usados para especificar vários IDs de e-mail -
void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingExceptionAqui está a descrição dos parâmetros -
type- Isso seria definido como TO, CC ou BCC. Aqui, CC representa Carbon Copy e BCC representa Black Carbon Copy. Exemplo Message.RecipientType.TO
addresses- Esta é a matriz de ID de email. Você precisaria usar o método InternetAddress () ao especificar os IDs de email.
Envie um email HTML
Aqui está um exemplo para enviar um e-mail HTML de sua máquina. Aqui, presume-se que seulocalhostestá conectado à Internet e é capaz de enviar um e-mail. Ao mesmo tempo, certifique-se de que todos os arquivos jar do pacote Java Email API e JAF estejam disponíveis em CLASSPATH.
Este exemplo é muito semelhante ao anterior, exceto que aqui estamos usando o método setContent () para definir o conteúdo cujo segundo argumento é "text / html" para especificar que o conteúdo HTML está incluído na mensagem.
Usando este exemplo, você pode enviar o conteúdo HTML que desejar.
// 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();
}
}
}Compile e execute o servlet acima para enviar mensagem HTML em um determinado ID de email.
Enviar anexo por e-mail
Aqui está um exemplo para enviar um e-mail com anexo de sua máquina. Aqui, presume-se que seulocalhost está conectado à Internet e é capaz de enviar um 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();
}
}
}Compile e execute o servlet acima para enviar um arquivo como anexo junto com uma mensagem em um determinado ID de email.
Parte de autenticação do usuário
Se for necessário fornecer ID de usuário e senha ao servidor de e-mail para fins de autenticação, você pode definir essas propriedades da seguinte maneira -
props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");O resto do mecanismo de envio de email permaneceria conforme explicado acima.
A estrutura do aplicativo da web envolvendo o subdiretório WEB-INF é padrão para todos os aplicativos da web Java e especificada pela especificação da API do servlet. Dado um nome de diretório de nível superior de myapp. Esta é a aparência desta estrutura de diretório -
/myapp
/images
/WEB-INF
/classes
/libO subdiretório WEB-INF contém o descritor de implantação do aplicativo, denominado web.xml. Todos os arquivos HTML devem ser mantidos no diretório de nível superior, que é myapp . Para o usuário administrador, você encontrará o diretório ROOT como o diretório pai.
Criação de servlets em pacotes
O diretório WEB-INF / classes contém todas as classes de servlet e outros arquivos de classe, em uma estrutura que corresponde ao nome do pacote. Por exemplo, se você tiver um nome de classe totalmente qualificado decom.myorg.MyServlet, então esta classe de servlet deve estar localizada no seguinte diretório -
/myapp/WEB-INF/classes/com/myorg/MyServlet.classA seguir está o exemplo para criar a classe MyServlet com um nome de pacote 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.
}
}Compilando servlets em pacotes
Não há nada muito diferente para compilar uma classe disponível no pacote. A maneira mais simples é manter seu arquivo java em um caminho totalmente qualificado, pois a classe mencionada acima seria mantida em com.myorg. Você também precisaria adicionar este diretório em CLASSPATH.
Supondo que seu ambiente esteja configurado corretamente, entre <Tomcat-installationdirectory>/ webapps / ROOT / WEB-INF / diretório classes e compilar MyServlet.java como segue
$ javac MyServlet.javaSe o servlet depende de qualquer outra biblioteca, você deve incluir esses arquivos JAR em seu CLASSPATH também. Incluí apenas o arquivo JAR servlet-api.jar porque não estou usando nenhuma outra biblioteca no programa Hello World.
Esta linha de comando usa o compilador javac integrado que vem com o Sun Microsystems Java Software Development Kit (JDK). Para que esse comando funcione corretamente, você deve incluir a localização do Java SDK que está usando na variável de ambiente PATH.
Se tudo correr bem, a compilação acima produzirá MyServlet.classarquivo no mesmo diretório. A próxima seção explicaria como um servlet compilado seria implantado na produção.
Implantação de Servlet em Pacote
Por padrão, um aplicativo servlet está localizado no caminho <Tomcat-installationdirectory> / webapps / ROOT e o arquivo de classe deve residir em <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Se você tiver um nome de classe totalmente qualificado de com.myorg.MyServlet, então essa classe de servlet deve estar localizada em WEB-INF / classes / com / myorg / MyServlet.class e você precisa criar as seguintes entradas em web.xml arquivo localizado em <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>As entradas acima devem ser criadas dentro das tags <web-app> ... </web-app> disponíveis no arquivo web.xml. Pode haver várias entradas disponíveis nesta tabela, mas não importa.
Você está quase terminando, agora vamos iniciar o servidor tomcat usando <Tomcat-installationdirectory> \ bin \ startup.bat (no Windows) ou <Tomcat-installationdirectory> /bin/startup.sh (no Linux / Solaris etc.) e finalmente digite http://localhost:8080/MyServletna caixa de endereço do navegador. Se tudo correr bem, você obterá o seguinte resultado -
Hello World
É sempre difícil testar / depurar servlets. Os servlets tendem a envolver uma grande quantidade de interação cliente / servidor, tornando os erros prováveis, mas difíceis de reproduzir.
Aqui estão algumas dicas e sugestões que podem ajudá-lo em sua depuração.
System.out.println ()
System.out.println () é fácil de usar como marcador para testar se um determinado trecho de código está sendo executado ou não. Podemos imprimir os valores das variáveis também. Adicionalmente -
Como o objeto System faz parte dos objetos Java principais, ele pode ser usado em qualquer lugar sem a necessidade de instalar nenhuma classe extra. Isso inclui Servlets, JSP, RMI, EJBs, Beans e classes comuns e aplicativos independentes.
A técnica de parada em pontos de interrupção interrompe a execução normal, portanto, leva mais tempo. Já a gravação em System.out não interfere muito no fluxo de execução normal do aplicativo, o que o torna muito valioso quando o tempo é crucial.
A seguir está a sintaxe para usar System.out.println () -
System.out.println("Debugging message");Todas as mensagens geradas pela sintaxe acima seriam registradas no arquivo de log do servidor web.
Registro de mensagens
É sempre uma boa ideia usar o método de registro adequado para registrar todas as mensagens de depuração, aviso e erro usando um método de registro padrão. Eu uso o log4J para registrar todas as mensagens.
A API Servlet também fornece uma maneira simples de enviar informações usando o método log () da seguinte forma -
// 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
}O ServletContext registra suas mensagens de texto no arquivo de log do contêiner de servlet. Com o Tomcat, esses registros são encontrados em <Tomcat-installation-directory> / logs.
Os arquivos de log fornecem uma indicação de novos bugs emergentes ou a frequência dos problemas. Por essa razão, é bom usar a função log () na cláusula catch de exceções que normalmente não deveriam ocorrer.
Usando JDB Debugger
Você pode depurar servlets com os mesmos comandos jdb usados para depurar um miniaplicativo ou aplicativo.
Para depurar um servlet, depuramos sun.servlet.http.HttpServer e observamos cuidadosamente enquanto o HttpServer executa servlets em resposta às solicitações HTTP feitas do navegador. Isso é muito semelhante a como os miniaplicativos são depurados. A diferença é que, com os miniaplicativos, o programa real sendo depurado é sun.applet.AppletViewer.
A maioria dos depuradores esconde esse detalhe sabendo automaticamente como depurar miniaplicativos. Até que eles façam o mesmo com os servlets, você deve ajudar o seu depurador fazendo o seguinte -
Defina o classpath do seu depurador de forma que ele possa localizar sun.servlet.http.Http-Server e classes associadas.
Defina o classpath do seu depurador para que ele também possa encontrar seus servlets e classes de suporte, normalmente server_root / servlets e server_root / classes.
Você normalmente não gostaria de server_root / servlets em seu classpath porque desabilita o recarregamento de servlet. Essa inclusão, no entanto, é útil para depuração. Ele permite que seu depurador defina pontos de interrupção em um servlet antes que o carregador de servlet personalizado em HttpServer carregue o servlet.
Depois de definir o classpath adequado, comece a depurar sun.servlet.http.HttpServer. Você pode definir pontos de interrupção em qualquer servlet que esteja interessado em depurar e, em seguida, usar um navegador da web para fazer uma solicitação ao HttpServer para o servlet fornecido (http: // localhost: 8080 / servlet / ServletToDebug). Você deve ver a execução sendo interrompida em seus pontos de interrupção.
Usando comentários
Comentários em seu código podem ajudar o processo de depuração de várias maneiras. Os comentários podem ser usados de muitas outras maneiras no processo de depuração.
O Servlet usa comentários Java e comentários de linha única (// ...) e de linha múltipla (/ * ... * /) podem ser usados para remover temporariamente partes de seu código Java. Se o bug desaparecer, dê uma olhada no código que você acabou de comentar e descubra o problema.
Cabeçalhos de cliente e servidor
Às vezes, quando um servlet não se comporta conforme o esperado, é útil examinar a solicitação e a resposta HTTP brutas. Se você estiver familiarizado com a estrutura do HTTP, poderá ler a solicitação e a resposta e ver exatamente o que está acontecendo com esses cabeçalhos.
Dicas importantes de depuração
Aqui está uma lista de mais algumas dicas de depuração sobre depuração de servlet -
Lembre-se de que server_root / classes não recarrega e que server_root / servlets provavelmente sim.
Peça a um navegador para mostrar o conteúdo bruto da página que está exibindo. Isso pode ajudar a identificar problemas de formatação. Geralmente é uma opção do menu Exibir.
Certifique-se de que o navegador não esteja armazenando em cache a saída de uma solicitação anterior, forçando uma recarga completa da página. Com o Netscape Navigator, use Shift-Reload; com o Internet Explorer, use Shift-Refresh.
Verifique se o método init () do seu servlet usa um parâmetro ServletConfig e chama super.init (config) imediatamente.
Antes de prosseguirmos, deixe-me explicar três termos importantes -
Internationalization (i18n) - Isso significa habilitar um site para fornecer diferentes versões de conteúdo traduzido para o idioma ou nacionalidade do visitante
Localization (l10n) - Isso significa adicionar recursos a um site para se adaptar a uma determinada região geográfica ou cultural.
locale- Esta é uma determinada região cultural ou geográfica. É geralmente referido como um símbolo de idioma seguido por um símbolo de país que é separado por um sublinhado. Por exemplo, "en_US" representa a localidade em inglês dos EUA.
Há uma série de itens que devem ser cuidados durante a construção de um site global. Este tutorial não fornecerá detalhes completos sobre isso, mas fornecerá um bom exemplo de como você pode oferecer sua página da web em diferentes idiomas para a comunidade da Internet, diferenciando sua localização, ou seja, localidade.
Um servlet pode obter a versão apropriada do site com base na localidade do solicitante e fornecer a versão apropriada do site de acordo com o idioma, cultura e requisitos locais. A seguir está o método do objeto de solicitação que retorna o objeto Locale.
java.util.Locale request.getLocale()Detectando localidade
A seguir estão os métodos de localidade importantes que você pode usar para detectar a localização do solicitante, idioma e, claro, localidade. Todos os métodos abaixo exibem o nome do país e o nome do idioma definidos no navegador do solicitante.
| Sr. Não. | Método e Descrição |
|---|---|
| 1 | String getCountry() Este método retorna o código do país / região em maiúsculas para este local no formato ISO 3166 de 2 letras. |
| 2 | String getDisplayCountry() Este método retorna um nome para o país do local apropriado para exibição ao usuário. |
| 3 | String getLanguage() Este método retorna o código do idioma em minúsculas para este local no formato ISO 639. |
| 4 | String getDisplayLanguage() Este método retorna um nome para o idioma do local apropriado para exibição ao usuário. |
| 5 | String getISO3Country() Este método retorna uma abreviação de três letras para o país desta localidade. |
| 6 | String getISO3Language() Este método retorna uma abreviação de três letras para o idioma deste local. |
Exemplo
Este exemplo mostra como você exibe um idioma e país associado para uma solicitação -
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>"
);
}
}Configuração de idiomas
Um servlet pode gerar uma página escrita em um idioma da Europa Ocidental, como inglês, espanhol, alemão, francês, italiano, holandês, etc. Aqui é importante definir o cabeçalho ContentLanguage para exibir todos os caracteres corretamente.
O segundo ponto é exibir todos os caracteres especiais usando entidades HTML, por exemplo, "& # 241;" representa "ñ" e "& # 161;" representa "¡" da seguinte forma:
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ñ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ñol:" + "</h1>\n" +
"<h1>" + "¡Hola Mundo!" + "</h1>\n" +
"</body>
</html>"
);
}
}Datas específicas da localidade
Você pode usar a classe java.text.DateFormat e seu método getDateTimeInstance () estático para formatar a data e a hora específicas para o local. A seguir está o exemplo que mostra como formatar datas específicas para um determinado local -
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>"
);
}
}Moeda específica da localidade
Você pode usar a classe java.txt.NumberFormat e seu método getCurrencyInstance () estático para formatar um número, como um tipo longo ou duplo, em uma moeda específica do local. A seguir está o exemplo que mostra como formatar uma moeda específica para um determinado local -
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>"
);
}
}Porcentagem específica da localidade
Você pode usar a classe java.txt.NumberFormat e seu método getPercentInstance () estático para obter a porcentagem específica do local. A seguir está o exemplo que mostra como formatar a porcentagem específica para um determinado local -
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>"
);
}
}Até agora, você aprendeu como o Servlet usa o descritor de implementação (arquivo web.xml) para implementar seu aplicativo em um servidor web. Servlet API 3.0 introduziu um novo pacote chamado javax.servlet.annotation. Ele fornece tipos de anotação que podem ser usados para anotar uma classe de servlet. Se você usar anotação, o descritor de implantação (web.xml) não será necessário. Mas você deve usar tomcat7 ou qualquer versão posterior do tomcat.
As anotações podem substituir a configuração XML equivalente no arquivo descritor de implementação da web (web.xml), como declaração de servlet e mapeamento de servlet. Os contêineres de servlet irão processar as classes anotadas no momento da implantação.
Os tipos de anotação introduzidos no Servlet 3.0 são -
| Sr. Não. | Anotação e descrição |
|---|---|
| 1 | @WebServlet Para declarar um servlet. |
| 2 | @WebInitParam Para especificar um parâmetro de inicialização. |
| 3 | @WebFilter Para declarar um filtro de servlet. |
| 4 | @WebListener Para declarar um WebListener |
| 5 | @HandlesTypes Para declarar os tipos de classe que um ServletContainerInitializer pode manipular. |
| 6 | @HttpConstraint Essa anotação é usada na anotação ServletSecurity para representar as restrições de segurança a serem aplicadas a todos os métodos de protocolo HTTP para os quais um elemento HttpMethodConstraint correspondente NÃO ocorre na anotação ServletSecurity. |
| 7 | @HttpMethodConstraint Esta anotação é usada na anotação ServletSecurity para representar restrições de segurança em mensagens de protocolo HTTP específicas. |
| 8 | @MultipartConfig Anotação que pode ser especificada em uma classe de Servlet, indicando que as instâncias do Servlet esperam pedidos que estejam em conformidade com o tipo MIME multipart / form-data. |
| 9 | @ServletSecurity Esta anotação é usada em uma classe de implementação de Servlet para especificar as restrições de segurança a serem aplicadas por um contêiner de Servlet em mensagens de protocolo HTTP. |
Aqui, discutimos algumas das anotações em detalhes.
@WebServlet
O @WebServlet é usado para declarar a configuração de um Servlet com um contêiner. A tabela a seguir contém a lista de atributos usados para anotação WebServlet.
| Sr. Não. | Atributo e descrição |
|---|---|
| 1 | String name Nome do Servlet |
| 2 | String[] value Matriz de padrões de URL |
| 3 | String[] urlPatterns Matriz de padrões de URL aos quais este filtro se aplica |
| 4 | Int loadOnStartup O valor inteiro dá a você a dica de ordem inicial |
| 5 | WebInitParam[] initParams Matriz de parâmetros de inicialização para este Servlet |
| 6 | Boolean asyncSupported Operação assíncrona suportada por este Servlet |
| 7 | String smallIcon Pequeno ícone para este Servlet, se presente |
| 8 | String largeIcon Ícone grande para este Servlet, se presente |
| 9 | String description Descrição deste Servlet, se presente |
| 10 | String displayName Exibir o nome deste Servlet, se presente |
Pelo menos um padrão de URL DEVE ser declarado no value ou urlPattern atributo da anotação, mas não ambos.
o value atributo é recomendado para uso quando o padrão de URL é o único atributo sendo definido, caso contrário, o urlPattern atributo deve ser usado.
Exemplo
O exemplo a seguir descreve como usar a anotação @WebServlet. É um servlet simples que exibe o textoHello 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>");
}
}Compilar Simple.java da maneira usual e coloque seu arquivo de classe em <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Agora tente chamar qualquer servlet executando apenas http: // localhost: 8080 / Simple . Você verá a seguinte saída na página da web.
Hello servlet@WebInitParam
A anotação @WebInitParam é usada para especificar um parâmetro de inicialização para um Servlet ou Filtro. É usado em anotações WebFilter ou WebSevlet. A tabela a seguir contém a lista de atributos usados para anotação WebInitParam.
| Sr. Não. | Atributo e descrição |
|---|---|
| 1 | String name Nome do parâmetro de inicialização |
| 2 | String value Valor do parâmetro de inicialização |
| 3 | String description Descrição do parâmetro de inicialização |
Exemplo
O exemplo a seguir descreve como usar a anotação @WeInitParam junto com a anotação @WebServlet. É um servlet simples que exibe o textoHello Servlet e o valor da string Hello World! que são retirados do init parâmetros.
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>");
}
}Compilar Simple.java da maneira usual e coloque seu arquivo de classe em <Tomcat-installationdirectory>; / webapps / ROOT / WEB-INF / classes.
Agora tente chamar qualquer servlet executando apenas http: // localhost: 8080 / Simple . Você verá a seguinte saída na página da web.
Hello Servlet
Hello World!@Webfilter
Esta é a anotação usada para declarar um filtro de servlet. Ele é processado pelo contêiner no momento da implementação e o filtro correspondente é aplicado aos padrões de URL, servlets e tipos de dispatcher especificados.
o @WebFiltera anotação define um filtro em um aplicativo da web. Essa anotação é especificada em uma classe e contém metadados sobre o filtro que está sendo declarado. O filtro anotado deve especificar pelo menos um padrão de URL. A tabela a seguir lista os atributos usados para anotação WebFilter.
| Sr. Não. | Atributo e descrição |
|---|---|
| 1 | String filterName Nome do filtro |
| 2 | String[] urlPatterns Fornece matriz de valores ou urlPatterns aos quais o filtro se aplica |
| 3 | DispatcherType[] dispatcherTypes Especifica os tipos de despachante (Solicitação / Resposta) aos quais o filtro se aplica |
| 4 | String[] servletNames Fornece uma matriz de nomes de servlet |
| 5 | String displayName Nome do filtro |
| 6 | String description Descrição do filtro |
| 7 | WebInitParam[] initParams Matriz de parâmetros de inicialização para este filtro |
| 8 | Boolean asyncSupported Operação assíncrona suportada por este filtro |
| 9 | String smallIcon Pequeno ícone para este filtro, se presente |
| 10 | String largeIcon Ícone grande para este filtro, se presente |
Exemplo
O exemplo a seguir descreve como usar a anotação @WebFilter. É um LogFilter simples que exibe o valor de Init-paramtest-parame o carimbo de data / hora atual no console. Isso significa que o filtro funciona como uma camada de interface entre a solicitação e a resposta. Aqui usamos "/ *" para urlPattern. Isso significa que este filtro é aplicável a todos os 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*/
}
}Compilar Simple.java da maneira usual e coloque seu arquivo de classe em <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Agora tente chamar qualquer servlet executando apenas http: // localhost: 8080 / Simple . Você verá a seguinte saída na página da web.
Hello Servlet
Hello World!Agora, abra o console do servlet. Lá, você encontrará o valor doinit parâmetro testparam e a current timestamp junto com mensagens de notificação de servlet.