Programação de Servlets

Acesso a Bancos de Dados com JDBC

O Problema: Aplicação de Suporte Técnico

Queremos implementar uma aplicação simples de Suporte Técnico usada por um Help Desk
Não temos tempo de implementar uma solução completa
- Queremos apenas mostrar como acessar um banco de dados relacional numa aplicação
Nossa aplicação tem a seguinte funcionalidade básica:
- Cadastrar um problema no banco de dados de suporte do help desk
  - Cada pedido de suporte recebe uma identificação única
- Listar todos os problemas de suporte no banco de dados
- Examinar os detalhes de um pedido de suporte particular

A Demo

Exercite a aplicação aqui
- http://anjinho.dsc.ufpb.br:8000/techsup
- Isso é uma máquina Linux
(Tomará que o professor tenha deixado a aplicação executando antes da aula ...)
- Caso contrário, o presente material mostra como implementar e fazer o deployment da aplicação e a demo poderá ser realizada no final

A Teoria sobre Servlets e JDBC

Para entendermos a solução, temos que aprender alguns detalhes adicionais sobre como servlets funcionam e como podem acessar um banco de dados

Vários servlets numa mesma aplicação

Nossa aplicação tem que gerar 3 páginas dinâmicas:
- Confirmação do cadastro
- Lista completa de pedidos de suporte
- Detalhamento de um pedido de suporte
Podemos usar um único servlet para gerar essas três páginas, ou 2 servlets ou até 3 servlets, um por página
Usaremos 3 servlets, para mostrar como fazer uma aplicação com vários servlets
Os servlets se chamarão:
- TechSupServlet: para cadastrar um pedido e gerar a página de confirmação de cadastro
- TechSupListaServlet: para listar todos os pedidos do banco de dados
- TechSupDetalhaServlet: para listar os detalhes de um pedido particular

Sobre JDBC e o acesso a Bancos de Dados

Criação do Banco de Dados

A aplicação manipula o seguinte banco de dados:

CREATE TABLE SUPP_REQUESTS(
  REQUEST_ID INTEGER PRIMARY KEY,
  NOME       VARCHAR(40),
  SOBRENOME  VARCHAR(40),
  EMAIL      VARCHAR(40),
  FONE       VARCHAR(40),
  SOFTWARE   VARCHAR(40),
  SO         VARCHAR(40),
  PROBLEMA   VARCHAR(256)
);

CREATE TABLE SEQ_NO(
  PROX_NUM   INTEGER
);

INSERT INTO SEQ_NO VALUES(0);

A tabela SUPP_REQUESTS contém os pedidos de suporte
A tabela SEQ_NO será usada para gerar números de sequência únicos
- A maioria dos BDs oferece uma forma mais eficiente de gerar números de sequência únicos para registros
- Exemplo: o ROWID do Oracle
- Geraremos os números "na mão" para exemplificar o uso de transações

DataSource e JNDI

Um banco de dados é visto como um Recurso do tipo DataSource
JNDI é usado para localizar o DataSource
- JNDI é essencialmente um repositório de objetos em rede
- JNDI = Java Naming and Directory Interface
Alguma aplicação (o J2EE server) vai cadastrar a URL para chegar ao banco de dados junto ao JNDI, junto com um nome JNDI para chamar o recurso
Uma outra aplicação (nosso servlet) usa JNDI para localizar o recurso usando seu nome JNDI
InitialContext é uma classe do pacote JNDI (javax.naming)
- É o ponto de entrada básico para usar o serviço de naming JNDI
O método lookup() é usado para consultar o serviço de naming

import java.sql.*;
import javax.sql.*;
import javax.naming.*;
import java.util.*;

public class TechSupDB {
  Connection con;
  private String dbName = "java:comp/env/jdbc/TechSupDB";

  public TechSupDB() throws Exception {
    try  {               
      InitialContext ic = new InitialContext();
      DataSource ds = (DataSource)ic.lookup(dbName);
      con =  ds.getConnection();
    } catch (Exception ex) {
      throw new Exception("Nao pode abrir conexao para o banco de dados: " +
                          ex.getMessage());
    }
  }
    
  public void remove() {
    try {
      con.close();
    } catch (SQLException ex) {
      System.out.println(ex.getMessage());
    }
  }
  // ...
}

No código acima, o que significa "java:comp/env/jdbc/TechSupDB"?
- JNDI armazena os nomes que mapeia numa hierarquia de "contextos"
- O prefixo java:comp/env é o nome do contexto JNDI para o ambiente de nomes do componente
- O que é isso?
- O "ambiente de nomes" (naming environment) é um mecanismo que permite que um componente seja customizado sem acessar o componente ou alterar seu código.
- O ambiente de nomes é implementado pelo container
- O container provê este ambiente ao componente através de um contexto de nomes JDNI (o contexto java:comp/env)
- Entradas neste ambiente são especificadas declarativamente no Deployment Descriptor do componente
- Nomes JNDI para objetos do tipo DataSource são armazenados no subcontext java:comp/env/jdbc

Abertura e fechamento de conexão de BD

Um banco de dados é acessado usando o pacote JDBC do Java
- Pacotes java.sql e javax.sql
Para acessar o banco, deve-se:
- Localizar o DataSource correspondendo ao BD
- Obter uma conexão para o BD
DataSource é usado com JDBC 2.0
- Anteriormente, tinha que usar a classe DriverManager e carregar o driver no código
Localizar o DataSource usando JNDI já carrega o driver apropriado
- Nosso código não precisa mais saber de drivers, URL da base de dados, etc.
- Precisamos apenas saber o nome "java:comp/env/jdbc/TechSupDB", por exemplo
- Onde esse recurso fica é problema do JNDI
A Connection que recebemos com ds.getConnection() vem de um pool de conexões e não tem necessariamente uma conexão física de banco de dados alocada permanentemente a ela
Isso faz com que obter uma conexão assim seja muito barato
Observe também a forma de fechar a conexão
Uma SQLException pode ser lançada pelo pacote JDBC

Como fazer um query e processar a resposta

Podemos usar uma conexão para preparar um statement SQL
A execução de um statement SELECT é feita com executeQuery()
- Aqui, queremos retornar uma ArrayList com todos os pedidos

public class TechSupDB {
  // ...
  public Collection getTechSupRequests() throws RequestsNotFoundException {
    ArrayList techSupRequests = new ArrayList();
    try {
      String selectStatement = "select * from SUPP_REQUESTS";
      PreparedStatement prepStmt = con.prepareStatement(selectStatement);
      ResultSet rs = prepStmt.executeQuery();

      while (rs.next()) {
        techSupRequests.add(new RequestDetails(
                                         rs.getInt(1),
                                         rs.getString(2),
                                         rs.getString(3),
                                         rs.getString(4), 
                                         rs.getString(5), 
                                         rs.getString(6), 
                                         rs.getString(7), 
                                         rs.getString(8)));
      }
      rs.close();
      prepStmt.close();
    } catch(SQLException ex) {
      throw new RequestsNotFoundException(ex.getMessage());
    }
    Collections.sort(techSupRequests);
    return techSupRequests;
  }

A resposta do query está disponível num "ResultSet" como visto acima
rs.next() move o cursor uma linha para baixo no ResultSet

Outro exemplo de query

O exemplo abaixo mostra outro query SQL
- Aqui, queremos obter os detalhes de um pedido com requestId (chave) conhecido

public class TechSupDB {
  // ...
  public RequestDetails getRequestDetails(int requestId)
                        throws RequestNotFoundException {
    try {
      String selectStatement = "select * from SUPP_REQUESTS where REQUEST_ID = ?";
      PreparedStatement prepStmt = con.prepareStatement(selectStatement);
      prepStmt.setInt(1, requestId);
      ResultSet rs = prepStmt.executeQuery();
      if (rs.next()) {
        RequestDetails requestDetail = new RequestDetails(
                                         rs.getInt(1),
                                         rs.getString(2),
                                         rs.getString(3),
                                         rs.getString(4), 
                                         rs.getString(5), 
                                         rs.getString(6), 
                                         rs.getString(7), 
                                         rs.getString(8));
        rs.close();
        prepStmt.close();
        return requestDetail;
      } else {
        rs.close();
        prepStmt.close();
        throw new RequestNotFoundException("Nao pode achar request: " + 
                                           requestId);
      }
    } catch (SQLException ex) {
      throw new RequestNotFoundException("Nao pode achar request: " + 
                                         requestId + " " + ex.getMessage());
    }
  }

prepStmt.setInt(1, requestId); significa atribuir requestId ao primeiro "?" do statement SQL

Como adicionar informação ao banco

O método executeUpdate() é usado para executar um "INSERT" em SQL

public class TechSupDB {
  // ...
  public int addRequest(String nome,
                        String sobrenome, String email,
                        String fone, String software,
                        String so, String problema) 
                        throws RequestNotInsertedException {

    int requestId = 0;
    try {
      requestId = getPróximoNúmero();
    } catch (SQLException ex) {
      throw new RequestNotInsertedException("Nao pode obter requestId: " + 
                                            ex.getMessage());
    }
    try {
      String insertStatement = "insert into SUPP_REQUESTS VALUES(?, ?, ?, ?, ?, ?, ?, ?)";
      PreparedStatement prepStmt = con.prepareStatement(insertStatement);
      prepStmt.setInt(1, requestId);
      prepStmt.setString(2, nome);
      prepStmt.setString(3, sobrenome);
      prepStmt.setString(4, email);
      prepStmt.setString(5, fone);
      prepStmt.setString(6, software);
      prepStmt.setString(7, so);
      prepStmt.setString(8, problema);
      con.setAutoCommit(true);
      prepStmt.executeUpdate();
      prepStmt.close();
    } catch (SQLException ex) {
      throw new RequestNotInsertedException("Nao pode inserir request: " + 
                                         requestId + " " + ex.getMessage());
    }
    return requestId;
  }

O método getPróximoNúmero() retorna um novo número de identificação de pedido
- Veremos a implementação abaixo
setAutoCommit(true) significa que alterações ao banco sofrem commit imediato
Em seguida, veremos um exemplo de uma transação envolvendo mais de um statement

Tratamento de transações

Como obter um número de sequência único para servir de chave para o pedido?
Muitos bancos de dados oferecem a geração automática de números de sequência únicos
- ROWID do Oracle, por exemplo
Aqui, geraremos nosso próprio número
Precisaremos de dois statements SQL para efetuar o trabalho e é importante que o controle de concorrência serialize os acessos por parte das várias sessões da aplicação que poderiam estar executando ao mesmo tempo
Para resolver o problema, desligamos o "autocommit" da conexão e fazemos o commit() manualmente
- Existe também o método rollback(), caso seja necessário

public class TechSupDB {
  // ...
  private int getPróximoNúmero() throws SQLException {
    final String updateStatementStr = "UPDATE SEQ_NO SET PROX_NUM = PROX_NUM + 1";
    final String selectStatementStr = "SELECT PROX_NUM FROM SEQ_NO";
    PreparedStatement updateStatement = con.prepareStatement(updateStatementStr);
    PreparedStatement selectStatement = con.prepareStatement(selectStatementStr);
    con.setAutoCommit(false);
    // Incrementa sequenciador
    updateStatement.executeUpdate();
    updateStatement.close();
    // Pega número de sequência
    ResultSet rs = selectStatement.executeQuery();
    rs.next();
    int next = rs.getInt(1);

    selectStatement.close();
    con.commit();
    // volta ao valor original do auto commit
    con.setAutoCommit(true);
    return next;
  }

Terminamos nosso tratamento inicial de JDBC

Sobre o ciclo de vida de um servlet

Examine a figura abaixo:

servlet3.gif (13571 bytes)

Durante sua vida, o servlet passa pelas seguintes etapas:
- Instanciação
  - O Web Container cria uma instância do servlet
- Inicialização
  - O Web Container chama o método init() do servlet
- Serviço
  - Se o container receber um pedido para o servlet, o método service() do servlet é chamado
- Destruição
  - Antes de destruir a instância, o Web Container chama o método destroy() do servlet
- Não disponível
  - A instância é destruída e marcada para coleta de lixo

Sobre o compartilhamento de informação entre servlets

Usaremos os métodos init() e destroy() para obter e liberar um objeto TechSupDB para acessar o banco de dados
Porém, temos 3 servlets e cada um tem seus métodos init() e destroy()
Como queremos tratar o objeto TechSupDB?
- Queremos compartilhá-lo entre todos os servlets que compõem a aplicação
A seguinte tabela mostra como fazer compartilhamento através de objetos de escopos variados

Escopo	Classe	Quem pode acessar?
Contexto Web (a aplicação toda)	javax.servlet.ServletContext	Qualquer componente Web da aplicação
Sessão	javax.servlet.http.HttpSession	Qualquer componente Web tratando de um pedido da sessão
Pedido	subtipo de javax.servlet.ServletRequest	Qualquer componente Web tratando do pedido
Página	javax.servlet.jsp.PageContext	A página JSP que cria o objeto (Veja outro capítulo sobre JSP)

Portanto, no nosso caso, queremos armazenar nosso objeto único techSupDB no ServletContext para que seja compartilhado por todos os servlets da aplicação
Temos três questões:
- Onde colocar o "new TechSupDB()" que será o objeto compartilhado entre os servlets?
- Como armazenar o objeto compartilhado no ServletContext?
- Como acessar o objeto compartilhado uma vez que ele está no ServletContext?
Primeira pergunta: onde criar o objeto compartilhado?
- Temos que fazer com que o Container chame algum código nosso que poderá fazer o "new TechSupDB()"
- Fazemos isso através do design pattern Observer
- Em vários momentos "interessantes", o Web Container gera um evento e o envia para os interessados cadastrados junto a ele
- No nosso caso, os dois eventos que importam são:
  - contextInitialized (a aplicação está iniciando)
  - contextDestroyed (a aplicação está terminando)
- Usaremos o evento contextInitialized para criar um objeto TechSupDB e colocá-lo no contexto da aplicação
  - Este objeto abre uma conexão para o BD
- Usaremos contextDestroyed para fechar a conexão ao BD
A classe ContextListener faz o trabalho:
- A instanciação dessa classe e seu cadastro junto ao Container serão feitos durante a composição da aplicação

import javax.servlet.*;

public final class ContextListener
  implements ServletContextListener {
  private ServletContext context = null;

  public void contextInitialized(ServletContextEvent event) {
    context = event.getServletContext();
   
    try {
      context.setAttribute("techSupDB", new TechSupDB());
    } catch (Exception ex) {
      context.log("Nao pode criar o objeto de base de dados de pedidos: " + ex.getMessage());
    }
  }
    
  public void contextDestroyed(ServletContextEvent event) {
    context = event.getServletContext();
    TechSupDB techSupDB = (TechSupDB)context.getAttribute("techSupDB");
    techSupDB.remove();
    context.removeAttribute("techSupDB");
  }
}

Estamos também vendo no código acima a resposta à segunda pergunta: Como armazenar o objeto compartilhado no ServletContext?

    context.setAttribute("techSupDB", new TechSupDB());

Como se pode ver, um nome é associado ao objeto para poder recuperá-lo depois
A recuperação do objeto é feita assim, em cada servlet:

public class TechSupServlet extends HttpServlet {
  private TechSupDB techSupDB;

  public void init() throws ServletException {
    techSupDB = (TechSupDB)getServletContext().getAttribute("techSupDB");
    if(techSupDB == null) {
      throw new UnavailableException("Nao pode obter o banco de dados.");
    }
  }
  // ...

A Solução

A classe TechSupDB

Já vimos a parte de acesso ao Banco de Dados com a classe TechSupDB
- Isolamos nesta classe todo o acesso ao banco de dados
- O resto do código usa os seguintes métodos:
  - Collection getTechSupRequests()
  - RequestDetails getRequestDetails(int requestId)
  - int addRequest(String nome, ..., String problema)
    - Retorna o requestId
  - void remove()
Todo o código da classe já foi visto acima

A classe RequestDetails

Essa classe não possui responsabilidades e existe apenas para conter dados
O método compareTo é necessário para estabelecer a ordem desejada devido à chamada seguinte em TechSupDB.getTechSupRequests():

    Collections.sort(techSupRequests);

O ContextListener

Já vimos o ContextListener acima

techsup.html

Esta é a "Welcome page" da aplicação: a primeira página exibida
Seu conteúdo segue
- Observe os alias que usaremos para os servlets (/cadastra, /lista)

<html>

<head>
<title>UFPb - Help Desk</title>
</head>

<body>

<h1>Pedido de Suporte Técnico - Help Desk da UFPb</h1>

<hr>

<p align="center"><br>
</p>

<form ACTION="/techsup/cadastra" METHOD="POST">
  <table ALIGN="center" WIDTH="100%" CELLSPACING="2" CELLPADDING="2">
    <tr>
      <td ALIGN="right">Nome:</td>
      <td><input TYPE="Text" NAME="nome" ALIGN="LEFT" SIZE="15"></td>
      <td ALIGN="right">Sobrenome:</td>
      <td><input TYPE="Text" NAME="sobrenome" ALIGN="LEFT" SIZE="15"></td>
    </tr>
    <tr>
      <td ALIGN="right">Email:</td>
      <td><input TYPE="Text" NAME="email" ALIGN="LEFT" SIZE="25"></td>
      <td ALIGN="right">Fone:</td>
      <td><input TYPE="Text" NAME="fone" ALIGN="LEFT" SIZE="15"></td>
    </tr>
    <tr>
      <td ALIGN="right">Software:</td>
      <td><select NAME="software" SIZE="1">
        <option VALUE="Word">Microsoft Word</option>
        <option VALUE="Excel">Microsoft Excel</option>
        <option VALUE="Access">Microsoft Access</option>
      </select> </td>
      <td ALIGN="right">Sistema Operacional:</td>
      <td><select NAME="so" size="1">
        <option VALUE="95">Windows 95</option>
        <option VALUE="98">Windows 98</option>
        <option VALUE="NT">Windows NT</option>
        <option VALUE="2000">Windows 2000</option>
      </select> </td>
    </tr>
  </table>
  <p><br>
  Descrição do Problema<br>
  <textarea NAME="problema" COLS="50" ROWS="4"></textarea> </p>
  <hr>
  <p><br>
  <input TYPE="submit" NAME="submit" VALUE="Submeter Pedido"> </p>
</form>

<p><a href="/techsup/lista">Listar pedidos de suporte existentes</a></p>
</body>
</html>

TechSupServlet

Este é o servlet de cadastro

// Import Servlet packages
import javax.servlet.*;
import javax.servlet.http.*;

// Import other Java packages
import java.io.*;
import java.sql.*;

public class TechSupServlet extends HttpServlet {
  private TechSupDB techSupDB;

  public void init() throws ServletException {
    techSupDB =
            (TechSupDB)getServletContext().getAttribute("techSupDB");
    if(techSupDB == null) {
      throw new UnavailableException("Nao pode obter o banco de dados.");
    }
  }

  public void destroy() {
    techSupDB.remove();
    techSupDB = null;
  }

  protected void doPost(HttpServletRequest req, HttpServletResponse res) 
          throws ServletException, IOException {
    String nome = req.getParameter("nome");
    String sobrenome = req.getParameter("sobrenome");
    String email = req.getParameter("email");
    String fone = req.getParameter("fone");
    String software = req.getParameter("software");
    String so = req.getParameter("so");
    String problema = req.getParameter("problema");
    // deveria verificar os parametros para ter certeza que não são nulos
    int requestId = 0;
    try {
      requestId = techSupDB.addRequest(nome, sobrenome, email, fone,
                             software, so, problema);
    } catch (RequestNotInsertedException e) {
      throw new ServletException("Erro no banco de dados: ", e);
    } 

    // Prepara resposta
    PrintWriter out = res.getWriter();

    res.setContentType("text/html");

    out.println("<HTML><HEAD><TITLE>");
    out.println("Suporte Técnico: Confirmação de Pedido");
    out.println("</TITLE></HEAD>");
    out.println("<BODY>");
    out.println("<H1>Suporte Técnico: Confirmação de Pedido</H1>");
    out.println("<P>Obrigado por seu pedido. Recebemos seu pedido e ele recebeu o número de identificação seguinte.</P>");
    out.println("<P>Identificação do Pedido: " + requestId + "</P>");
    out.println("<P>Favor anotar este número para referência futura.</P>");
    out.println("<P>Atenderemos seu pedido nos próximos 24 horas.</P>");
    out.println("<P>O administrador<br>Equipe de Suporte Técnico. </P>");
    out.println("</BODY></HTML>");

    out.close();
  } 
}

TechSupListaServlet

Este servlet obtém a coleção de pedidos e e a exibe em HTML

// Import Servlet packages
import javax.servlet.*;
import javax.servlet.http.*;

// Import other Java packages
import java.io.*;
import java.util.*;
import java.sql.*;

public class TechSupListaServlet extends HttpServlet {
  private TechSupDB techSupDB;

  public void init() throws ServletException {
    techSupDB =
            (TechSupDB)getServletContext().getAttribute("techSupDB");
    if(techSupDB == null) {
      throw new UnavailableException("Nao pode obter o banco de dados.");
    }
  }

  public void destroy() {
    techSupDB.remove();
    techSupDB = null;
  }

  protected void doGet(HttpServletRequest req, HttpServletResponse res) 
          throws ServletException, IOException {

    Iterator it = null;
    try {
      Collection requests = techSupDB.getTechSupRequests();
      it = requests.iterator();
    } catch(RequestsNotFoundException e ) {
      throw new ServletException("Erro no banco de dados: ", e);
    }
    PrintWriter out = res.getWriter();
    res.setContentType("text/html");
    out.println("<HTML><HEAD>");
    out.println("<LINK REL=\"stylesheet\" TYPE=\"text/css\" HREF=\"style.css\"/>");
    out.println("<TITLE>");
    out.println("Suporte Técnico: Lista de Pedidos");
    out.println("</TITLE>");
    out.println("</HEAD>");
    out.println("<BODY>");
    out.println("<H1>Suporte Técnico: Lista de Pedidos</H1>");
    out.println("<TABLE CLASS=\"clsIndex\">");
    out.println("<TR>");
    out.println("<TD CLASS=\"clsBigNav\">");
    out.println("Identificação de pedido");
    out.println("</TD>");
    out.println("<TD CLASS=\"clsBigNav\">");
    out.println("Sobrenome");
    out.println("</TD>");
    out.println("<TD CLASS=\"clsBigNav\">");
    out.println("Software");
    out.println("</TD>");
    out.println("</TR>");
    while(it.hasNext()) {
      RequestDetails rd = (RequestDetails)it.next();
      out.println("<TR>");
      out.println("<TD CLASS=\"clsTitle\">");
      out.println("<a href=\"/techsup/detalha?requestId=" + rd.getRequestId() + "\">");
      out.println(rd.getRequestId());
      out.println("</A>");
      out.println("</TD>");
      out.println("<TD CLASS=\"clsTitle\">");
      out.println(rd.getSobrenome());
      out.println("</TD>");
      out.println("<TD CLASS=\"clsTitle\">");
      out.println(rd.getSoftware());
      out.println("</TD>");
      out.println("</TR>");
    }
    out.close();
  } 
}

TechSupDetalhaServlet

Este servlet dá detalhes de um pedido
É muito simples, como os outros servlets, já que camada de acesso aos dados está isolada em TechSupDB

// Import Servlet packages
import javax.servlet.*;
import javax.servlet.http.*;

// Import other Java packages
import java.io.*;
import java.util.*;
import java.sql.*;

public class TechSupDetalhaServlet extends HttpServlet {
  private TechSupDB techSupDB;

  public void init() throws ServletException {
    techSupDB =
            (TechSupDB)getServletContext().getAttribute("techSupDB");
    if(techSupDB == null) {
      throw new UnavailableException("Nao pode obter o banco de dados.");
    }
  }

  public void destroy() {
    techSupDB.remove();
    techSupDB = null;
  }

  protected void doGet(HttpServletRequest req, HttpServletResponse res) 
          throws ServletException, IOException {

    int requestId = Integer.parseInt(req.getParameter("requestId"));
    RequestDetails rd = null;
    try {
      rd = techSupDB.getRequestDetails(requestId);
    } catch(RequestNotFoundException e) {
      throw new ServletException("Erro no banco de dados: ", e);
    }

    PrintWriter out = res.getWriter();
    res.setContentType("text/html");
    out.println("<HTML><HEAD>");
    out.println("<LINK REL=\"stylesheet\" TYPE=\"text/css\" HREF=\"style.css\"/>");
    out.println("<TITLE>");
    out.println("Suporte Técnico: Detalhe de Pedido");
    out.println("</TITLE>");
    out.println("</HEAD>");
    out.println("<BODY>");
    out.println("<H1>Suporte Técnico: Detalhe de Pedido</H1>");
    out.println("<H2>Identificação de Pedido: " + rd.getRequestId() + "</H2>");
    out.println("<UL>");
    out.println("<LI>Nome: " + rd.getNome() + "</LI>");
    out.println("<LI>Sobrenome: " + rd.getSobrenome() + "</LI>");
    out.println("<LI>Email: " + rd.getEmail() + "</LI>");
    out.println("<LI>Fone: " + rd.getFone() + "</LI>");
    out.println("<LI>Software: " + rd.getSoftware() + "</LI>");
    out.println("<LI>SO: " + rd.getSo() + "</LI>");
    out.println("<LI>Problema: " + rd.getProblema() + "</LI>");
    out.println("</UL>");
    out.close();
  } 
}

A Composição da Aplicação

Imagine que esteja usando a máquina do desenvolvedor da aplicação
- Lembre que não estamos no servidor J2EE
- Tampouco estamos usando uma máquina dos clientes que eventualmente comprarão a aplicação
- Esta é a máquina onde o programador compõe a aplicação
Vamos compilar tudo:

C:\...\src>ant techsup
Buildfile: build.xml

init:

techsup:
    [mkdir] Created dir: C:\...\build\techsup
     [copy] Copying 2 files to C:\...\build\techsup
    [javac] Compiling 10 source files to C:\...\build\techsup

BUILD SUCCESSFUL

Total time: 5 seconds

Agora, vamos compor a aplicação usando o deploytool
- Criar nova aplicação TechSupApp no diretório src/techsup
- Criar um novo Web component TechSupAppWAR com conteúdo
  - Todos os arquivos .class de build/techsup e techsup.html e style.css
  - Tipo Servlet, com classe de servlet TechSupServlet, alias /cadastra
- Adicionar a TechSupAppWAR um novo servlet com classe de servlet TechSupListaServlet, alias /lista
- Adicionar a TechSupAppWAR um novo servlet com classe de servlet TechSupDetalhaServlet, alias /detalha
- Na orelha "Event Listeners", adicione ContextListener
- Na orelha "File Refs", adicione "techsup.html" como Welcome File
- Salve para criar o arquivo TechSupApp.ear (a aplicação)
- Envie o arquivo TechSupApp.ear para seu cliente final (junto com a fatura ...)
- Na realidade, para testar, o desenvolvedor da aplicação também faria um deployment, é claro

O Deployment da Aplicação

Estamos agora nas dependências do cliente final
Use deploytool para terminar de ajustar o Deployment Descriptor
- Já fizemos um pouco de deployment antes ao acertar o nome dos aliases dos servlets
  - Esses nomes poderiam ser alterados agora durante o deployment
- Adiciona referência de recurso para o banco de dados Cloudscape
  - Selecione TechSupAppWAR
  - Selecione a orelha "Resource Ref"
  - Clique em "Add"
  - Selecione "javax.sql.DataSource" na coluna Type
  - Insira "jdbc/TechSupDB" no campo "Coded Name"
  - Insira "jdbc/TechSupDB" no campo "JNDI Name"
    - Não é obrigado a ser o mesmo nome do Coded Name
    - Adiante, veremos como fazer com que o servidor J2EE cadastre a URL associada ao JNDI Name junto ao JNDI (usando o comando j2eeadmin)
- Em TechSupApp, defina um "Context root" com valor "/techsup"
- Salve para criar o arquivo TechSupApp.ear
Agora, precisamos preparar o servidor de banco de dados, o servidor J2EE e depois fazer o deployment da aplicação

No servidor de banco de dados

Criação do banco de dados
- cloudscape -start
- ant create-techsup-db
Os comandos SQL executados para criar o banco de dados estão em createdb.sql:

DROP TABLE SUPP_REQUESTS;
CREATE TABLE SUPP_REQUESTS(
  REQUEST_ID INTEGER PRIMARY KEY,
  NOME       VARCHAR(40),
  SOBRENOME  VARCHAR(40),
  EMAIL      VARCHAR(40),
  FONE       VARCHAR(40),
  SOFTWARE   VARCHAR(40),
  SO         VARCHAR(40),
  PROBLEMA   VARCHAR(256)
);

DROP TABLE SEQ_NO;
CREATE TABLE SEQ_NO(
  PROX_NUM   INTEGER
);

INSERT INTO SEQ_NO VALUES(0);

No servidor J2EE

Configurar o servidor J2EE para que saiba sobre o nome JNDI jdbc/TechSupDB
- Ao entrar no ar, o servidor J2EE fará o bind de jdbc/TechSupDB com a URL indicada

j2ee -stop
j2eeadmin -addJdbcDatasource jdbc/TechSupDB jdbc:cloudscape:rmi:TechSupDB;create=true

Na segunda linha, a sintaxe é:

j2eeadmin -addJdbcDatasource <nome JNDI> <URL>

Agora, o servidor J2EE pode entrar no ar:

j2ee -verbose

Uma das linhas impressas durante a inicialização será:

Binding DataSource, name = jdbc/TechSupDB, url = jdbc:cloudscape:rmi:TechSupDB;create=true

É neste momento que o servidor J2EE contacta o serviço JNDI
- O servidor de nomes sendo usado para fornecer o que está por trás do JNDI é o "RMI JDBCServer", no caso do servidor grátis que vem com o J2EE SDK
Outros produtos podem usar outros serviços de nomes (NDS, Active Directory, ...)

Na máquina de deployment

Agora passamos para a máquina do cliente final a partir da qual o deployment está sendo feito
- Essa máquina não precisa ser o servidor mas pode ser
- O deployment pode ser remoto
Use o deploytool e escolha Tools/Deploy
- Faça deploy de TechSupApp.ear no servidor desejado
Execute a aplicação:
- http://anjinho.dsc.ufpb.br:8000/techsup
Experimente em casa causando erros nos servlets
- Por exemplo, desconecte o banco de dados
  - Comando: "cloudscape -stop"

Conclusão

Observe que os seguintes passos podem ser feitos em máquinas diferentes com sistemas operacionais diferentes (Windows, Linux, ...)
- Compilação
- Composição da aplicação com deploytool (criar o arquivo .ear)
- Deployment da aplicação com deploytool
- Execução no Servidor
Também, observe que o banco de dados poderia executar numa máquina diferente do servidor
- Bastaria mudar o Deployment Descriptor para que isso ocorresse, sem necessidade de recompilação

techsupport programa