Java para Web
231 pág.

Java para Web


DisciplinaOrientação A Objetos170 materiais1.087 seguidores
Pré-visualização45 páginas
<filter-class>br.com.caelum.servlet.filtro.FiltraGif</filter-class>
</filter>
<filter-mapping>
<filter-name>FiltraGif</filter-name>
<url-pattern>*.gif</url-pattern>
</filter-mapping>
Note a similaridade do mapeamento de uma servlet com o de um filtro.
11.5 - Exercícios
1) Crie uma classe chamada LogFiltro no pacote br.com.caelum.servlet.filtro.
2) Faça sua classe implementar javax.servlet.Filter. O Eclipse vai reclamar que faltam alguns métodos.
Após o eclipse mostrar o erro de compilação acima, utilize a tecla de atalho CTRL+1 para resolver o erro:
escreva a definição dos três métodos (add unimplemented methods).
Os métodos init e destroy já são conhecidos pois funcionam exatamente como definimos para as servlets.
3) Implemente o conteúdo método doFilter:
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws ServletException, IOException {
// executa o que desejar antes de continuar
System.out.println(&quot;Nova requisição para :&quot;
+ ((HttpServletRequest) request).getRequestURI());
// continua
chain.doFilter(request, response);
// executa o que desejar depois de continuar
System.out.println(&quot;Requisição terminada&quot;);
}
Capítulo 11 - Servlet e JSP API - Configuração de filtros - Página 100
Material do Treinamento Java para Desenvolvimento Web
4) Agora, vamos mapear todos os JSPs para executarem primeiro esse filtro:
<filter>
<filter-name>LogFiltro</filter-name>
<filter-class>br.com.caelum.servlet.filtro.LogFiltro</filter-class>
</filter>
<filter-mapping>
<filter-name>LogFiltro</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
5) Teste a URL http://localhost:8080/jspteste/bemvindo.jsp
11.6 - Entendendo os filtros
A maneira mais simples de entender os filtros é visualizá-los como camadas que são executadas uma depois
das outras, sem saber o que acontece.
Durante o curso, comentaremos sobre alguns controladores, e a idéia de filtros é normalmente chamada de
Interceptadores neles.
Tais interceptadores ganharam fama primeiro no Jboss e depois no Tomcat, neste segundo sob o nome de
válvulas, e são tão importantes que podem ser utilizados para controle de autorização e autenticação, upload,
compactação de arquivos a serem baixados etc, sempre sem mudar uma linha de código da sua lógica de
negócios.
11.7 - Exercício Opcional
1) Faça um Filtro que diga quanto tempo a sua servlet demorou para executar
Capítulo 11 - Servlet e JSP API - Entendendo os filtros - Página 101
CAPÍTULO 12
Model View Controller
\u201cEnsinar é aprender duas vezes.\u201d
\u2013 Joseph Joubert
O padrão arquitetural MVC e o request dispatcher.
12.1 - Servlet ou JSP?
Colocar todo HTML dentro de uma Servlet realmente não parece a melhor idéia. O que acontece quando
precisamos mudar o design da página? O seu designer não vai ter tempo de editar sua Servlet, recompilá-la e
colocá-la no servidor.
Uma idéia mais interessante é usar o que é bom de cada um dos dois.
O JSP foi feito apenas para apresentar o resultado, e ele não deveria fazer acessos a bancos e outros. Isso
deveria estar na Servlet.
O ideal então é que a Servlet faça o trabalho sujo e árduo, e o JSP apenas apresente esses resultados. A
Servlet possui a lógica de negócios (ou regras de negócio)e o JSP tem a lógica de apresentação.
Imagine o código do método da servlet AdicionaContatoServlet que fizémos antes:
protected void service(
HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// log
System.out.println(&quot;Tentando criar um novo contato...&quot;);
// acessa o bean
Contato contato = new Contato();
// chama os setters
...
// adiciona ao banco de dados
ContatoDAO dao = new ContatoDAO();
dao.adiciona(contato);
// ok.... visualização
request.getWriter().println(&quot;<html>Ok</html>&quot;);
}
102
Material do Treinamento Java para Desenvolvimento Web
Repare que, no final do nosso método, misturamos o código HTML com Java. O que queremos extrair do
código acima é justamente essa última linha (ou mais linhas em um caso de HTML maior).
Seria muito mais interessante para o programador e para o designer ter um arquivo JSP chamado
contato-adicionado.jsp apenas com o HTML:
<html>
Ok
</html>
A ferramenta que buscamos é um redirecionador de requisições, capaz de enviar uma requisição para um
novo recurso do servidor: um jsp, uma servlet, uma imagem etc.
Podemos usar o recurso de dispatch das requisições para que o JSP só seja chamado depois de que
suas regras foram executadas.
12.2 - Request dispatchers
Poderíamos melhorar a nossa aplicação se trabalhássemos com o código Java na servlet e depois o código
HTML em uma página JSP.
A API da servlet nos permite fazer tal redirecionamento. Basta conhecermos a URL que queremos acessar
e podemos usar o que fora chamado de RequestDispatcher para acessar outro recurso web, seja esse recurso
uma página jsp ou uma servlet:
RequestDispatcher rd = request.getRequestDispatcher(&quot;/contato-adicionado.jsp&quot;);
rd.forward(request,response);
Agora podemos facilmente executar a lógica de nossa aplicação web em uma servlet e então redirecionar
para uma página jsp, onde você possui seu código html.
Capítulo 12 - Model View Controller - Request dispatchers - Página 103
Material do Treinamento Java para Desenvolvimento Web
Forward e include
O método forward só pode ser chamado quando nada fora escrito para a saída. No momento que
algo for escrito fica impossível redirecionar o usuário pois o protocolo http não possui meios de
voltar atrás naquilo que já foi enviado ao cliente.
Existe outro método da classe RequestDispatcher que representa a inclusão de página e não o
redirecionamento. Esse método se chama include e pode ser chamado a qualquer instante para
acrescentar ao resultado de uma página os dados de outra.
Apesar dos dois métodos parecerem úteis eles não costumam ser usados a não ser na parte de
controlador de uma aplicação web utilizando o padrão MVC.
12.3 - Exercícios
1) Altere sua servlet AdicionaContatoServlet para que, após a execução da lógica de negócios, o fluxo da
requisição seja redirecionado para um JSP chamado contato-adicionado.jsp:
a) Substitua as linhas:
PrintWriter writer = response.getWriter();
writer.println(&quot;<html>&quot;);
writer.println(&quot;Contato Adicionado&quot;);
writer.println(&quot;</html>&quot;);
por:
RequestDispatcher rd = request.getRequestDispatcher(&quot;/contato-adicionado.jsp&quot;);
rd.forward(request,response);
b) Faça o arquivo contato-adicionado.jsp na pasta WebContent.
<html>
Contato Adicionado
</html>
2) Teste a url: http://localhost:8080/jspteste/testa-adiciona-contato.jsp
Capítulo 12 - Model View Controller - Exercícios - Página 104
Material do Treinamento Java para Desenvolvimento Web
Resultado
Perceba que já atingimos um resultado que não era possível anteriormente.
Muitos projetos antigos que foram escritos em Java, utilizavam somente jsp ou servlets e o resultado era
assustador. Com o conteúdo mostrado até esse momento, é possível escrever um código com muito mais
qualidade do que esses projetos.
12.4 - Melhorando o processo
Aqui temos várias servlets acessando o banco de dados, trabalhando com os DAOs e pedindo para que o
JSP apresente esses dados, o diagrama a seguir mostra a representação do AdicionaContatoServlet após a
modificação do exercício anterior.
Agora temos o problema de ter muitas servlets. Para cada lógica de negócios, teríamos uma servlet dife-
rente, que significa oito linhas de código no web.xml... algo abominável em projeto de verdade. Imagine dez
classes de modelo, cinco lógicas diferentes, isso totaliza quatrocentas linhas de configuração.
Sabemos da existência de ferramentas para gerar tal código automaticamente, mas isso não resolve o
problema da complexidade de administrar tantas servlets.
Utilizaremos uma idéia que diminuirá a configuração