JSP – Java para Internet.

Olá Computêros, estou aqui mais uma vez pra compartilhar outra descoberta, bom, estou testando e aprendendo JSP e logo-logo, estarei compartilhando mais algumas descobertas. Abaixo um texto falando sobre.

O que é JSP ?

JSP é um acrônimo para Java Server Pages e consiste numa linguagem de script baseada em java para criação de sites com conteúdos dinâmicos.

Inicialmente as páginas na Web eram apenas páginas estáticas, isto é, seu conteúdo não variava a cada solicitação conforme algum parâmetro. Com a sofisticação dos serviços disponibilizados via Web, surgiu a necessidade de disponibilizar informações com natureza dinâmica (lista de preços atualizados, compras on-line, etc). Isso exigiu que o servidor web fizesse algum processamento adicional da solicitação a fim de gerar uma resposta personalizada. Algumas tecnologias para geração de conteúdo dinamicamente são:

CGI – Common Gateway Interface

O CGI foi primeiro padrão para conteúdo da Web dinâmico. Ele é um protocolo de comunicação que o servidor HTTP utiliza para conversação com outro programa. Um CGI script é qualquer programa (PERL, C, Java) que se comunica com o servidor WEB através do protocolo CGI. Um script CGI (como ficou conhecido este mecanismo) é um programa que atende às requisições enviadas por um cliente e a ele repassadas pelo servidor HTTP.

Um CGI tradicional possui algumas ineficiências que limitam sua aplicabilidade em sistemas Web de grande escala. Uma delas deve-se ao fato de que um programa CGI roda fora do servidor Web e não como um subprocesso do servidor. Dessa forma um novo processo deve ser criado cada vez que um programa CGI precisa ser executado, o que ocasiona um overhead considerável para o servidor. Outro problema é que os programas de CGI são projetados para tratar de apenas uma única solicitação específica, na qual um novo processo é criado, as informações da solicitação são enviadas para ele, espera-se o processamento, a resposta é repassada de volta para o navegador e o processo é finalizado. Com isso fica difícil, por exemplo, dois CGI’s compartilharem recursos, o que otimizaria em muito a performance dos sistemas. É fácil imaginar os problemas de performance ocasionados por este modelo num site que atenda a milhares de solicitações simultâneas.

Para amenizar estes problemas, os novos sistemas para geração de conteúdo dinâmico assumem a forma de módulos que alavancam as interfaces de programas aplicativos específicos de servidor, a fim de interagir diretamente com o processo do servidor Web como um subprocesso do mesmo, evitando assim muito do overhead* associado aos programas CGI convencionais.

* Em ciência da computação overhead é geralmente considerado qualquer processamento ou armazenamento em excesso, seja de tempo de computação, de memória, de largura de banda ou qualquer outro recurso que seja requerido para ser utilizado ou gasto para executar uma determinada tarefa. Como conseqüência pode piorar o desempenho do aparelho que sofreu o overhead.

Servlets e JSP

Servlets são a alternativa Java para CGI Scripts e assim possuem todas as vantagens da plataforma à sua disposição : APIs, multiplataforma, multithreading, OO. Sua desvantagem é que tanto o conteúdo estático quanto o dinâmico residem no código fonte do programa, o que acarreta sérios problemas de manutenção.

JSP é a combinação de HTML com Java dentro de uma mesma página (como ASP e PHP), porém, usando-se tags especiais do tipo HTML que interagem com objetos Java no servidor, podemos introduzir conteúdo dinâmico em qualquer parte da página sem necessidade que código Java bruto apareça. Em princípio, todo o código fora dos tags é HTML puro. Isso possibilita gerar um código mais manutenível pois permite a separação do código que se destina a apresentação (HTML e tags) do código responsável por gerar o conteúdo dinâmico (tipicamente Java).

Execução de Servlets/JSP

Uma página JSP é tipicamente convertida para um servlet quando de sua compilação, por isso trataremos a forma de execução de ambos de forma indistinta.

Um servidor HTTP com suporte a servlets deve possuir um ServletEngine (container servlet) que é o software responsável por executá-los. Este software corresponde a um processo em Java separado do servidor HTTP rodando uma JVM e recebe todas as solicitações para execução de um servlet/jsp.

O fluxo para execução ocorre da seguinte maneira:

1. O servidor HTTP recebe a solicitação para execução de um servlet/jsp e a repassa, juntamente com os dados da solicitação, para o container.

2. O container verifica se aquele servlet já está carregado na memória. Se não estiver ou se houver uma versão mais nova do servlet, o container o carrega. O fato dos servlets mais recentes já estarem carregados na memória, representa em ganho de performance.

3. Uma vez inicializado, o servlet estará apto a lidar com centenas de acessos simultaneamente, disparando para cada acesso uma nova thread para atendê-lo (encadeamento), ao invés de criar um novo processo. As threads são muito menos custosas do que os processos convencionais, gerando um overhead muito menor para sua criação e destruição. Elas compartilham a mesma memória que a do processo pai e assim podem compartilhar recursos como conexões com banco de dados, dentre outros.

4. Ao término do processamento, o resultado é enviado de volta para o servidor Web e apenas a thread é encerrada, permanecendo o processo pai (servlet) ainda na memória.

ASP – Active Server Pages

É a solução da Microsoft para criação de páginas dinâmicas e suporta múltiplas linguagens de criação de scripts incluindo PerlScript , JScript e principalmente VBScript, um subconjunto da linguagem Visual Basic. Grande parte do poder desta solução está no fato de ser possível acessar componentes ActiveX através do VBScript.

PHP

É uma linguagem de script Open Source que disponibiliza suporte para uma vasta gama de recursos como acesso a banco de dados, comunicação com servidores de diretório, manipulação de arquivos, e-mail, dentre muitos outros.

Benefícios de JSP

JSP oferece diversos benefícios como um sistema para geração de conteúdo dinâmico. Tendo uma tecnologia baseada em Java, ela se aproveita de todas as vantagens que a linguagem Java fornece : orientação a objetos, tratamento de exceções, gerenciamento automático de memória, dentre outros aspectos que conduz a um ganho significativo de produtividade.

Pelo fato do bytecode de Java compilado ser portável através de todas as plataformas que possuam uma JVM, o uso de JSP não o restringe a uma plataforma de hardware, sistema operacional ou software específico (o que não é verdade com o ASP). Pelo fato de JSP ser neutra a fornecedores, os desenvolvedores e arquitetos de sistemas podem selecionar melhores soluções em todas as etapas de acionamento de JSP.

JSP pode se aproveitar de todas as APIs de Java padrão, incluindo aquelas para acesso a bancos de dados compatíveis com muitas plataformas, serviços de diretório, processamento distribuído, criptografia, etc.

Embora JSP permita que programadores implementem a geração de conteúdo dinâmico diretamente em páginas da web, ele também inclui um conjunto de tags do tipo HTML para interagir com objetos Java no servidor. Em especial, estas tags são projetadas para criar, realizar consultas e modificar JavaBeans no servidor. Ao se aproveitar do suporte embutido de JSP para JavaBeans, é possível manter uma rígida separação entre a apresentação dos dados ao usuário final e a implementação do código que gerou estes dados. Assim, uma manutenção na parte estática não interfere em qualquer código Java da programação e vice-versa.

Essa separação promove uma clara divisão de trabalho no desenvolvimento e manutenção dos sites com conteúdo dinâmico, o que possibilita melhor organizar equipes de desenvolvimento aproveitando o perfil de cada membro : designers, artistas gráfico, codificadores HTML cuidam da apresentação, enquanto programadores Java ficam responsáveis pela implementação.

Exemplo de um Servlet

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

public class SimpleServlet extends HttpServlet{ public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException,IOException{
PrintWriter out;
response.setContentType(“text/html”);
out = response.getWriter();
String user = request.getParameter(“usuario”);
if (user == null) user = “World”;
out.println(“<html><body>”);
out.println(“<h1>Simple Servlet Output</h1>”);
out.println(“<p>Hello, ” + user);
out.println(“</body></html>”); out.close();

Exemplo de um JSP equivalente

<html>
<body>
<%
String user = request.getParameter(“usuario”);
if (user == null)
user = “World”;
%>
<h1> Simple Servlet Output </h1>
<P>Hello, <%=user%>
</body>
</html>

Para não dizer que eu comecei a aprender pelo famoso “HELLO WORLD” fiz uma Tabuáda pra testar o JSP, segue abaixo o código:

<%@ page contentType="text/html; charset=utf-8" language="java" import="java.sql.*" errorPage="" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Untitled Document</title>
<style type="text/css">
<!--
.style1 {
color: #FFFFFF;
font-weight: bold;
}
-->
</style>
</head>
<body>
<h1>Tabuáda.</h1>
<table width="50%" border="1">
<tr bgcolor="#000000"><td width="35" bgcolor="#000000"><div align="center">x</div></td>
<%for(int c=0; c<=10; c++){%>
<td width="35"><div align="center"><%=c%></div></td>
<%}%>
<%for(int l=0; l<=10; l++){%>
<tr>
<td width="35" bgcolor="#000000"><div align="center"><%=l%></div></td>
<%for(int i=0; i<=10; i++){%>
<td width="35" <%if(i==l){%> bgcolor="#cccccc" <%}%>><div align="center"><%=i*l%></div></td>
<%}%>
<%}%>
</table>
</body>
</html>

Como ficou:

Para testar seu JSP ou Servlet não esqueça de copia-lo para um dos contextos padrões do Tomcat. Abaixo mais algumas informações importantes.

Como executar Servlets e JSP

Para executar Servlets e JSP é preciso implantálos em um Web Container.

Um Web Container pode estar executando como parte de um servidor HTTP que o repassa as requisições destinadas a servlets e JSP.

Neste post estou usando o Tomcat Web Container, que pode tanto funcionar conectado a outro servidor como o Apache, ou usar seu próprio servidor Web.

Estrutura do Tomcat

Como implantar uma aplicação no Tomcat

Há três maneiras de implementar

• Transferir os arquivos da aplicação (JSP, servlets) para contextos já reconhecidos pelo servidor
• Configurar um novo contexto (server.xml)
• Implantar a aplicação como um WebArchive(WAR)

Contextos são diretórios devidamente  configurados que o Tomcat reconhece como aplicações Web

Existem dois contextos default: examples e ROOT

Como usar o contexto ROOT

Para usar o contexto ROOT:

• Copie arquivos JSP, HTML, imagens, etc em $TOMCAT_HOME/webapps/ROOT
• Coloque beans, classes e servlets em $TOMCAT_HOME/webapps/ROOT/WEB-INF/classes
• Acesse páginas JSP usando http://servidor:8080/
• Acesse servlets usando http://servidor:8080/servlet/

Como usar o contexto examples

Para usar o contexto examples:

• Copie arquivos JSP, HTML, imagens, etc em $TOMCAT_HOME/webapps/examples
• Coloque beans, classes e servlets em $TOMCAT_HOME/webapps/examples/WEB-INF/classes
• Acesse páginas JSP usando http://servidor/examples/pagina.html
• Acesse servlets usando http://servidor/examples/servlet/pacote.Class

Lembrando que $TOMCAT_HOME é a pasta de instalação do TomCat, por padrão de instalação fica na pasta “C:\Arquivos de Programas\Apache Software Foundation\Tomcat X.X\”

Bom amigos, termino este post por aqui, assim que tiver novas informações continuarei com este post. Abraços.