Tecnologias Java EE: JDBC, Servlets, JSP e EJB

Tecnologias Java EE e Conectividade

• JDBC (Java Database Connectivity): Utilizado no acesso a bancos de dados.
• Servlets: Utilizados para o desenvolvimento de aplicações Web com conteúdo dinâmico.
• JSP (Java Server Pages): Uma especialização do servlet que permite que conteúdo dinâmico seja facilmente desenvolvido.
• JTA (Java Transaction API): Uma API que padroniza o tratamento de transações dentro de uma aplicação Java.
• EJBs (Enterprise Java Beans): Utilizados no desenvolvimento de componentes de software. Eles permitem que o programador se concentre nas necessidades do negócio do cliente.
• JCA (Java Connector Architecture): Uma API que padroniza a ligação a aplicações legadas.
• JPA (Java Persistence API): Uma API que padroniza o acesso a banco de dados através de mapeamento Objeto/Relacional dos Enterprise Java Beans.
• JMS (Java Message Service): Uma API para *middleware* orientado a mensagens.

Objetivos do Desenvolvimento de Aplicações

Desenvolver aplicações consiste em analisar e construir para:

• Resolver problemas de negócios;
• Automatização e informatização de processos;
• Facilitar a consulta a informações e dados.

Separação em Camadas e Responsabilidades

Cada parte de uma aplicação tem uma responsabilidade, e para cada responsabilidade existe uma camada:

• GUI – Interface com o usuário;
• Model – Modelo de negócio, classes de negócio;
• Persistência – Classes que permitem a manipulação dos objetos em repositórios de dados;
• Exceptions – Classes que representam exceções.

Elementos de uma Aplicação Web

• Baseado em Request-Response;
• Cliente abre conexão e envia *request* para o servidor;
• Cliente recebe *response* e fecha conexão;
• Comunicação sem estado (*stateless*);
• Para o servidor, cada *request* é o primeiro enviado pelo cliente;
• Cada recurso é identificado por um único e exclusivo Uniform Resource Identifier (URI);
• URL (Uniform Resource Locator) são URIs que especificam protocolos (HTTP, FTP, mailto).

URI, URL e URN

Uma URI pode ser classificada como um localizador (URL) ou um nome (URN), ou ainda como ambos. O URN define a identidade de um item, enquanto que o URL nos dá um método para encontrá-lo.

Hypertext Transfer Protocol (HTTP)

O HTTP é um protocolo de comunicação (na camada de aplicação conforme o Modelo OSI) base comum da WWW. O ciclo básico é: 1. Abre conexão; 2. HTTP Request; 3. HTTP Response; 4. Fecha conexão.

O protocolo HTTP define oito métodos que indicam a ação a ser realizada no recurso especificado. O método determina o que o servidor deve fazer com o URL fornecido no momento da requisição de um recurso. Um servidor HTTP deve implementar ao menos os métodos GET e HEAD.

Métodos HTTP (Exemplos)

• GET
  • Envia dados através da URI;
  • Menos seguro;
  • Pode navegar dados de um site para outro.
• POST
  • Envia dados através do fluxo da requisição;
  • Mais seguro;
  • Dados navegam somente no mesmo contexto.

Tipos de Aplicações Web

• Orientadas à apresentação: Páginas interativas contendo linguagens tais como: HTML, XML, DHTML, etc.
• Orientadas a serviços: Web Services.

Componentes Web

Componentes web são:

• Java Servlets;
• Páginas JSP;
• Web Services.

Servlet

É uma classe Java para estender as capacidades de servidores Web.

• Baseado no modelo *request / response*;
• Funciona através de *threads*: cada chamada executa uma *thread* diferente.
• O ciclo de vida de um Servlet é controlado pelo *container*;
• A classe HttpServlet fornece métodos para controle do ciclo de vida do Servlet pelo *container*:
  • init()
  • destroy()
  • service()

HttpServletRequest

• Define um objeto que fornece informações do *request* HTTP para o servlet;
• Provê dados tais como parâmetros e valores enviados pelo *browser*, atributos e *streams* de entrada; informações sobre o protocolo, endereço IP do cliente, etc;
• Estende a interface ServletRequest.

HttpServletResponse

• Define um objeto que permite ao servlet enviar resposta ao cliente web.
• Permite definir atributos no *header* HTTP e criar *cookies*.
• Estende a interface ServletResponse.

Estrutura de um *http request*: Protocolo/servidor/porta/contexto/uri/parâmetros.

Ciclo de Vida do Servlet

A implementação da interface Servlet (javax.servlet.Servlet) é usada para todos os servlets, porque é essa interface que encapsula os métodos do ciclo de vida do servlet. Nesse ciclo, existem os métodos:

init()

• Esse método consegue sobrecarregar códigos de iniciação que são executados apenas uma vez, antes do tratamento de qualquer solicitação por parte do usuário.
• Essa ação somente é completada com sucesso depois que o servlet não receber nenhuma solicitação.

service()

• Esse método é invocado quando chega a primeira solicitação do cliente, ou seja, depois que o método init() permitir ao servlet responder a uma solicitação.
• O *Container* inicia uma nova *thread* ou aloca uma *thread* de *pool*, onde é ativado o método service().

destroy()

• Esse método tem como objetivo remover o servlet, sendo invocado quando todas as sequências dentro do método service() forem finalizadas.

Etapas do Processamento de Requisição

1. O usuário faz uma solicitação através de um link ou botão do qual o servlet faz parte.
2. O *Container* verifica se a solicitação é para um servlet; se for, cria-se os objetos response (HttpServletResponse) e request (HttpServletRequest).
3. O *Container* localiza o servlet baseado na solicitação, onde é criada ou alocada uma *thread* para a solicitação, chamando o método service() do servlet, que passa como argumento os dois objetos *request* e *response*.
4. O método service() descobre qual método HTTP (GET ou POST) do servlet chamar.
5. O servlet usa o objeto response para escrever a resposta para o cliente, geralmente esse retorno já é a página HTML que vai ser exibida.
6. Quando invocado o método destroy(), o método service() termina, sendo que a *thread* morre ou retorna um para um *pool* de *threads* gerenciadas pelo *Container*.
7. As referências dos objetos de solicitação acabam saindo do escopo. Com isso, é executado um processo de limpeza da memória, que são enviadas para o *Garbage Collector*.

Configuração do Servlet

É usado o objeto ServletConfig. Esse objeto possui os seguintes métodos para fazer a recuperação:

• getInitParameterNames() - Não possui argumento e retorna um Enumeration, que contém todos os nomes de parâmetro no objeto ServletConfig.
• getInitParameter() – Possui como argumento uma *string* e retorna uma *string*.

Servlet Filters

Servlet Filters é um recurso do Java EE para interceptar uma requisição web antes do recurso final ser atingido, este recurso pode ser um servlet, um arquivo, entre outros.

Filtros são muito úteis quando precisamos configurar o ambiente para o recurso a ser atingido, como por exemplo, abrir e fechar a sessão do *hibernate* (openSessionInView), verificar se o usuário está logado ou se tem permissão de fazer a requisição, permitindo ou não acessar o recurso.

Um filtro é um objeto que implementa a classe javax.servlet.Filter e por isso deve definir três métodos:

• void init(FilterConfig config) throws ServletException
  • O método init é chamado uma vez antes do filtro entrar em operação pela primeira vez.
  • Como parâmetro é passado um FilterConfig de onde se pode obter o nome do filtro, os parâmetros de inicialização, e o ServletContext.
• void destroy()
  • O método destroy é chamado para avisar o filtro que ele está sendo desativado, e possa liberar eventuais recursos alocados.
• void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException
  • O método doFilter é onde é feito todo o processamento do filtro.
  • A primeira parte é executada antes de que o Servlet seja executado.
  • A chamada chain.doFilter transfere o controle para o próximo filtro.
  • A chamada só retorna quando o Servlet já foi processado, então, o código posterior a essa chamada será executado.
  • Ao chamar chain.doFilter passamos como parâmetro um *request* e um *response*, podemos facilmente alterá-los, criando *Wrappers* em torno de cada um deles.

Um exemplo de uso: Um Servlet gera um log do tempo que cada requisição levou. Para ter acesso ao log é preciso guardar o ServletContext, através do método init. Vale ressaltar também que o *request* recebido pelo filtro não é um HttpServletRequest, e portanto para conseguirmos a URI utilizada para chamar o Servlet precisa fazer um *cast*. Isso informa ao servidor que o filtro timerFilter é implementado pela classe TimerFilter.

Bancos de Dados e JDBC

• Um banco de dados é uma coleção organizada de dados.
• Um sistema de gerenciamento de bancos de dados (DBMS) fornece mecanismos para armazenar, organizar, recuperar e modificar dados para muitos usuários.
• SQL é a linguagem padrão internacional utilizada quase universalmente com bancos de dados relacionais para realizar consultas e para manipular dados.
• O JDK vem com um RDBMS puro Java chamado Java DB — a versão da Sun para o Apache Derby.
• Os programas Java comunicam-se com bancos de dados e manipulam seus dados utilizando a Java Database Connectivity (JDBC™) API.

Um banco de dados relacional é uma representação lógica de dados que permite que os dados sejam acessados sem considerar sua estrutura física. Um banco de dados relacional armazena dados em tabelas.

ResultSet e Conexão

O método Connection createStatement com dois argumentos recebe o tipo e a concorrência do *result set* (conjunto de resultados).

• O tipo de conjunto de resultados especifica se o cursor do ResultSet é capaz de rolar em ambas as direções ou apenas encaminhar e se o ResultSet é sensível a alterações feitas nos dados subjacentes.
• Se um ResultSet não for sensível a alterações, a consulta que o produziu deve ser novamente executada para refletir qualquer alteração feita.

Java Server Pages (JSP)

Tudo o que vale para servlets continua valendo para Java Server Pages.

• Um JSP é uma servlet durante a execução.
• Escrever código em JSP é como escrever código dentro do doPost() ou doGet() de um servlet com os objetos request, response, out, session e outros já definidos.
• Um JSP, depois de carregado, é tão veloz quanto uma servlet (pois um JSP é uma servlet).
• JSP é mais fácil de codificar e implantar, mas é mais difícil de depurar.
• Servlets forçam o programador a embutir código HTML dentro de código Java, o que é uma desvantagem se a maior parte do que tem que ser gerado é texto ou HTML estático, misturando as coisas.

JSP é uma tecnologia padrão, baseada em *templates* para servlets. O mecanismo que a traduz é embutido no servidor.

Compilação e Ciclo de Vida do JSP

Em um servidor que suporta JSP, a página JSP é transformada (compilada) em uma servlet.

A forma mais simples de criar documentos JSP é:

1. Mudar a extensão de um arquivo HTML para JSP.
2. Colocar o documento em um servidor onde suporte JSP.
3. Fazendo isso, o servidor gera uma servlet.
4. A compilação é feita no primeiro acesso.
5. Nos acessos subsequentes, a requisição é redirecionada à servlet gerada.

Mapeada para o JSP, o *container*:

• Verifica se a servlet correspondente à página é mais antiga que a página (ou se não existe).
• Se a servlet não existir, ou for mais antiga, a página JSP será compilada para gerar a nova servlet.

Desse ponto em diante o ciclo de vida é similar ao das servlets, mas os métodos são diferentes:

• Se a servlet ainda não existir, ela será instanciada, e seu método jspInit() é chamado.
• Para cada requisição, seu método _jspService(req,res) é chamado.
• No fim da vida, o método jspDestroy() é chamado.
• jspInit() e jspDestroy() permitem maior controle sobre o ciclo de vida da servlet.
• Ambos são opcionais, mas úteis para inicializar conexões, obter recursos, etc.