Acessando Bancos de Dados em Java e JSP

Autor: Galileu Batista <galileu at j2eebrasil.com.br>

1. Introdução

O Acesso a Base de Dados em JSP é um dos tópicos recorrentes entre os iniciantes em programação nesta plataforma. Este artigo é uma tentativa de mostrar, na prática, como a separação entre lógica de negócios e de apresentação, empregada pelos desenvolvedores do JSP, faz com que todos os princípios de acesso a base de dados em Java se apliquem uniformemente a Aplicações, Applets e Páginas JSP. O exemplo aqui discutido implementa a pesquisa de opinião sobre necessidades de treinamento, contida na seção de mesmo nome, do site http://www.jspbrasil.com.br/. Inicia-se desenvolvendo uma aplicação de uso na linha de comando. Em seguida o código já desenvolvido é usado para criação de uma aplicação usando GUI. Esta última é posteriormente convertida em um Applet, para uso dentro de um Web Browser. Finalmente, a aplicação original é utilizada como base para elaboração de páginas JSP para a pesquisa. O principal objetivo durante o curso da explanação é mostrar que a camada de apresentação, seja ela uma aplicação em terminal ou GUI, um applet ou páginas JSP, é apenas um detalhe, pois a lógica de negócio está encapsulada de modo a atender qualquer semântica de apresentação. De maneira secundária este artigo serve de introdução às plataformas Java e, em particular, JSP.

2. Preparando a Base de Dados

O processo de acesso a SGBDs em Java é independente do gerenciador, sendo implementado através de drivers JDBC (Java DataBase Connection). A estratégia de conexão a cada servidor de Banco de Dados varia ligeiramente, devendo-se consultar o manual do fornecedor para obter a seqüência de instruções correta. Estabelecida a conexão, os comandos de manipulação são independentes do servidor de dados.

Embora atualmente existam drivers JDBC para, virtualmente, todos os SGBD, esta não era a realidade de alguns anos atrás. Considerando a disponibilidade de drivers ODBC, a Sun, desenvolveu um driver JDBC que usa comandos ODBC para acesso a servidores de dados, viabilizando de imediato a sua tecnologia. Este driver tornou-se conhecido como ponte JDBC-ODBC e faz parte do Java SDK. Ignorando questões de desempenho, a forma de acesso é transparente à aplicação.

No desenvolvimento, por se tratar de uma aplicação simples utilizar-se-á uma base de dados Microsoft Access, com acesso através da ponte JDBC-ODBC. Deve-se então criar o arquivo no Access contendo uma única tabela: TREINAMENTO. O nome do arquivo que eu utilizei foi d:homeGalileuprojetosjspbrasildbopiniao.mbd. A seguir o SQL comando de criação da tabela.

CREATE TABLE TREINAMENTO ( nome varchar (50) NULL, fone varchar (15) NULL, celular varchar (15) NULL, email varchar (50) NULL, intmod1 int NULL, intmod2 int NULL, intmod3 int NULL, intmod4 int NULL, dispmod1 int NULL, dispmod2 int NULL, dispmod3 int NULL, dispmod4 int NULL )

Basicamente a tabela contém nome, telefone, celular, e-mail, interesse em cada um dos quatro módulos de treinamento (valores de 0 a10) e a disponibilidade de horário (valores de 1 a 3, relativos aos turnos).

Se preferir pode fazer o download do arquivo opiniao.mdb que está no formato Acess 2000. (clique com o botão direito do mouse >> opção "salvar link como...")

Criado o arquivo deve-se criar um vínculo ODBC, através do painel de controle, usando as telas abaixo.

Após registrado o alias ODBC, com o nome OPINIAO, e login de acesso tutdb, pode-se usar esta fonte de dados em programas Java. A senha cadastrada também foi tutdb.

3. Uma Aplicação Java para Manipulação da BD

Desenvolver-se-á agora uma classe Java (Pesquisa) que faz acesso à tabela no Banco de Dados. Esta classe manipula exatamente uma linha da tabela TREINAMENTO, tendo uma variável para cada campo no DB. Adicionalmente existe um um par de métodos (get/set) para cada uma das variáveis. Um trecho da classe Pesquisa está abaixo:

import java.sql.*; public class Pesquisa { // ... private String email; private int intmod1; private int dispmod1; private int acao; // ... public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public int getIntmod1() { return intmod1; } public void setIntmod1(int intmod1) { this.intmod1 = intmod1; } public int getAcao() { return acao; } public void setAcao(int acao) { this.acao = acao; } public boolean fazAcao() { if (acao == 1) { // Consultar } else if (acao == 2) { // Inserir } else if (acao == 3) { // Limpar campos } acao = 0; return true; } }

Download do arquivo Pesquisa.java (clique com o botão direito do mouse >> opção "salvar link como...")

Antes de discutir a semântica desta classe, um aspecto importante a mencionar é a padronização do nome das variáveis na classe em relação aos métodos get/set. Embora nehuma restrição de nomes seja imposta, o respeito à padronização JavaBeans, pode ser muito útil durante do desenvolvimento de páginas JSP, por exemplo.

JavaBeans sugere que o nome das variáveis seja escrito em letras minúsculas e que o métodos de acesso às mesmas iniciem com get (ou set) seguido do nome da variável com a primeira letra maiúscula. Por exemplo, a variável email, tem com métodos getEmail e setEmail.

3.1. A conexão ao Banco de Dados

Ausente do código da classe Pesquisa está o seu construtor. É no construtor (neste caso particular) que se efetua a conexão ao DB. Os detalhes de uma conexão são tipicamente complexos de elucidar num texto básico, pois envolvem elementos como ClassLoader, SecurityManager, etc., assim sendo serão focalizadas as partes mais simples.

static Connection con = null; public Pesquisa() { if (con == null) { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); con = DriverManager.getConnection ("jdbc:odbc:OPINIAO", "tutdb", "tutdb"); } catch (Exception e) { System.err.println ("Erro no comando de Conexao"); } } }

O comando Class.forName se encarrega de trazer a ponte JDBC-ODBC para uso no programa, os detalhes fogem ao escopo deste texto. É o comando DriverManager.getConection que de fato efetua a conexão, através de três parâmetros: o alias ODBC (precedido de jdbc:odbc:), o login e a senha.

Observe-se também que a conexão é compartilhada por todos os objetos que venham a ser criados a partir desta classe. Trata-se de uma versão simplificada (e perigosa) de um pool de conexões.

3.2. Inserção e Consulta de Dados

A inserção e busca de dados se dá no método fazAcao(). Este método faz uma consulta à variável acao e então executa código de acordo. Ou seja, antes de chamar fazAcao() é necessário chamar setAcao() passando um valor adequado. Nesta aplicação convenciona-se que acao==1 equivale a consulta, acao==2 a inserção, e, acao==3 limpa as variáveis do objeto.

É possível questionar se este método de trabalho não é muito complicado. A resposta é: esta filosofia será muito útil mais adiante, durante a construção das páginas JSP, ao mesmo em tempo que não inviabiliza as outras estratégias de deployment. Abaixo se encontra o código que faz o processo de consulta, sob o qual far-se-á a maior parte dos comentários.

import java.sql.*; public class Pesquisa { // .. public boolean fazAcao() { if (acao == 1) { try { Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery ("SELECT * FROM "+ TREINAMENTO WHERE NOME LIKE '%" + nome + "%'"); if (rs.next()) { nome = rs.getString(1); fone = rs.getString(2); celular = rs.getString("celular"); email = rs.getString(4); intmod1 = rs.getInt("intmod1"); intmod2 = rs.getInt(6); intmod3 = rs.getInt(7); intmod4 = rs.getInt (8); dispmod1 = rs.getInt(9); dispmod2 = rs.getInt(10); dispmod3 = rs.getInt(11); dispmod4 = rs.getInt(12); } else { acao = 3; fazAcao(); return false; } stmt.close(); } catch (Exception e) { System.err.println ("Erro no comando SQL de Consulta"); return false; } } // .... return true; } }

O primeiro comando (con.createStatement()) cria um objeto que é responsável pelo envio de comandos e recuperação de resultados junto ao SGBD. O envio de comandos para o banco é feito através dos métodos: executeQuery (consulta), execute (insert ou atualização) e update (atualização). No caso da consulta, tem-se como retorno um conjunto de dados acessível através do da interface ResultSet.

ResultSet (rs) especifica métodos de navegação no conjunto de dados retornado, bem como acesso aos campos do registro corrente. É importante mencionar que o primeiro registro visto pelo rs é de controle e informações sobre os dados retornados, portanto, antes de qualquer acesso deve-se executar rs.next(). O Acesso aos campos pode ser feito usando métodos da forma getXXX (campo), onde XXX é Int se o campos for int, Long se o campo for long e assim por diante. O campo a ser recuperado pode ser especificado em termos da sua posição (iniciando em 1) ou do seu nome (como string). O comando close sobre stmt é fundamental, pois libera imediatamente os recursos do banco, tais como cursores, o que de outra forma só seria efetuado na coleta de lixo, inviabilizando em alguns casos, novas operações.

Finalmente, todos os comandos devem ser postos dentro de um try/catch para tratamento de eventuais erros no acesso à base de dados. O processo de Inserção é muito similar e não será discutido.

Sumarizando, é a classe Pesquisa que implementa, usando JDBC, o conceito de persistência, servindo de mapeamento entre o Banco e os dados na memória. Qualquer aplicação que use a tabela TREINAMENTO, tem na classe Pesquisa seu ponto de comunicação com o SGBD.

3.3. A Aplicação em modo Terminal

Desenvolver uma aplicação Java para consulta à tabela TREINAMENTO resume-se a definir um objeto da classe Pesquisa, usar o método getNome (para indicar o pesquisado a recuperar), seguido de setAcao(1) (indicando que se trata de uma consulta), ainda seguido de fazAcao(). O proceso de inserção é simétrico: usa-se os métodos setXXX(), seguidos de setAcao(2) (indicando que se trata de uma inserção) e fazAcao(). A recuperação dos dados pode ser feita consultando cada um dos campos do objeto, usando métodos getXXX(). Uma versão simplificada segue:

public class TermPesquisa extends java.lang.Object { public static void main (String args[]) { Pesquisa p2 = new Pesquisa(); p2.setNome("Maria Joaquina"); p2.setEmail ("mjapg@jspbrasil.com.br"); p2.setIntmod3(8); p2.setDispmod3(1); p2.setAcao(2); p2.fazAcao(); Pesquisa p3 = new Pesquisa(); p3 = new Pesquisa(); p3.setNome("Joaquina"); p3.setAcao(1); p3.fazAcao(); System.out.println (p3.getNome()+": "+p3.getEmail()); } }

Download do arquivo TermPesquisa.java (clique com o botão direito do mouse >> opção "salvar link como...")

A lição aqui é a seguinte: Qualquer estratégia de apresentação deve, escrever os valores desejados para dentro do objeto Pesquisa, comandar a execução da ação e, se for o caso, ler os resultados de dentro do mesmo objeto; somente, então fazer a apresentação.

4. Uma Aplicação Visual para Manipulação da BD

Os detalhes dos procedimentos para obter uma aplicação gráfica em Java fogem ao escopo deste texto. O que pode ser dito é que há vários ambientes RAD: (IBM) VisualAge for Java, (WebGain) Visual Café, (Inprise) Jbuilder, (Sun) Forte for Java, entre outros. Existe também a possibilidade de "escrever o código a mão". Aqui, foi utilizado o Forte for Java, por ser gratuito e multiplataforma. A tela se resume a:

É suficiente saber que o Forte gera uma classe para cada formulário e, para aqueles que iniciam uma aplicação, um método main que cria um objeto da classe do formulário, caracterizando assim uma aplicação. Por se tratar de uma aplicação GUI, cabe observar o código de tratamento de eventos dos botões (cujo esquema é criado pelo Forte).

public class AplicPesquisa extends javax.swing.JFrame { // ... Pesquisa pesq = new Pesquisa(); private void jButton2ActionPerformed (java.awt.event.ActionEvent evt) { // Add your handling code here: INCLUIR telaparaDB(); pesq.setAcao(2); pesq.fazAcao(); } private void jButton2ActionPerformed (java.awt.event.ActionEvent evt) { // Add your handling code here: // CONSULTAR pesq.setNome (txNome.getText()); pesq.setAcao(1); pesq.fazAcao(); dBparaTela(); } }

Download do arquivo AplicPesquisa.java

Download do arquivo AplicPesquisa.form

Seguindo a lógica já mencionada, as ações consistem em chamar métodos da camada de apresentação (telaparaDB() e Dbparatela()) a fim de estabelecer/visualizar valores contidos em um objeto Pesquisa. A implementação dos métodos de apresentação segue:

public class AplicPesquisa extends javax.swing.JFrame { // ... private void telaparaDB() { pesq.setNome(txNome.getText()); pesq.setFone (txFone.getText()); pesq.setCelular( txCelular.getText()); pesq.setEmail(txEmail.getText()); pesq.setIntmod1(cbIntmod1.getSelectedIndex()); pesq.setIntmod2(cbIntmod2.getSelectedIndex()); pesq.setIntmod3(cbIntmod3.getSelectedIndex ()); pesq.setIntmod4(cbIntmod4.getSelectedIndex()); pesq.setDispmod1(cbDispmod1.getSelectedIndex()); pesq.setDispmod2(cbDispmod2.getSelectedIndex()); pesq.setDispmod3(cbDispmod3.getSelectedIndex ()); pesq.setDispmod4(cbDispmod4.getSelectedIndex()); } private void dBparaTela() { txNome.setText(pesq.getNome()); txFone.setText(pesq.getFone()); txCelular.setText (pesq.getCelular()); txEmail.setText(pesq.getEmail()); cbIntmod1.setSelectedIndex(pesq.getIntmod1()); cbIntmod2.setSelectedIndex(pesq.getIntmod2()); cbIntmod3.setSelectedIndex(pesq.getIntmod3 ()); cbIntmod4.setSelectedIndex(pesq.getIntmod4()); cbDispmod1.setSelectedIndex(pesq.getDispmod1()); cbDispmod2.setSelectedIndex(pesq.getDispmod2()); cbDispmod3.setSelectedIndex (pesq.getDispmod3()); cbDispmod4.setSelectedIndex(pesq.getDispmod4()); } }

Os métodos aplicados para recuperar e estabelecer valores aos componentes visuais são supostamente intuitivos. Convém caracterizar que conceitualmente não existe diferença conceitual entre as duas abordagens (Terminal ou GUI) para desenvolvimento de aplicações; a lógica está, de fato, em um outro nível, a classe Pesquisa.

5. Um Applet para Manipulação da BD

Um Applet difere de uma aplicação no sentido de que executa dentro de container que é outra aplicação, tipicamente um WEB Browser. O código do Applet reside em um servidor, mas antes da execução é trazido ao cliente, a partir daí toda a execução se dá neste. A forma de especificar que um Apllet deve ser executado é através de tags específicos em uma página HTML.

Existem fundamentalmente quatro métodos que controlam o funcionamento de um Applet: init(), start(), stop(), destroy(). O init() funciona como uma espécie de construtor, sendo executado uma só vez, quando é carregado. O método start() (destroy()) é chamado sempre que o Applet torna-se (deixa de ser) a página ativa do browser. Simplificadamente, destroy() é chamado quando o browser é fechado.

É sempre importante lembrar que um Applet sofre de muitas restrições de segurança, verificadas dinamicamente, quando comparado a uma aplicação. Conexões de rede, e portanto acesso a um banco de dados, só podem ser feitas à máquina de onde o código do Applet foi recuperado.

Feitas as ressalvas, pode-se evoluir na criação do Applet. Embora seja possível repetir todo o processo de criação visual em um formulário para um Applet, optou-se por criar no formulário apenas um botão, cuja única ação é a criação de um objeto AplicPesquisa, o qual já estudou-se o comportamento. Em verdade, o botão do Applet funciona como o método main de AplicPesquisa (que só é executado quando esta é chamada como Aplicação).

Como o acesso ao SGBD é feito usando ODBC, é fundamental que a máquina onde o Applet esteja executando tenha o alias apropriado. Didaticamente, recomenda-se que, inicialmente, todos estes exemplos sejam trabalhados em uma única máquina. O código do Applet, por completo, é exibido abaixo:

public class AppletPesquisa extends java.applet.Applet { public void init () { button1 = new java.awt.Button(); button1.setLabel("Rodar Aplicação"); button1.addActionListener (new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { button1ActionPerformed(evt); } } ); add(button1); } private void button1ActionPerformed(java.awt.event.ActionEvent evt) { (new AplicPesquisa()).show(); } private java.awt.Button button1; }

Download do arquivo AppletPesquisa.java

Download do arquivo AppletPesquisa.form

Finalmente, para executar o Applet é suficiente abrir o HTML abaixo:

<!doctype html public "-//w3c//dtd html 4.0 transitional//en"> <html> <head> <meta http-equiv="Content-Type" content="text/html"> <title>Applet HTML Page</title> </head> <body> <h3> <hr WIDTH="100%">Applet Page <hr WIDTH="100%"></h3> <applet code="AppletPesquisa.class" width=350 height=200></applet> </body> </html>

6. Uma página JSP para Manipulação da BD

JSP é uma tecnologia de geração de páginas dinâmicas que opera no lado do servidor, ou seja, o cliente recebe uma página contendo somente HTML, sendo papel do servidor adequar o conteúdo gerado para cada situação. Servlets tem são a base de implementação do JSP. Um servlet é um programa em Java (que respeita determinadas convenções), ativado pelo servidor WEB e tem, na sua maior parte, comandos para escrever o código HTML (que será devolvido ao cliente). O HTML a ser escrito pode depender de vários fatores, incluindo acessos a SGBDs.

Assim sendo, se o objetivo é escrever um servlet para implementara Pesquisa, é necessário ter alguma maneira de receber os parâmetros da busca (ou inserção), criar um objeto da classe Pesquisa, chamar os métodos apropriados desta e finalmente, escrever o HTML para o cliente. O processo de comunicação do servidor WEB com o browser é transparente ao desenvolvedor do Servlet. Vê-se, portanto, que não há diferença conceitual para os demais modos de apresentação.

Uma página JSP é uma mistura de HTML com Java. A separação se dá através de um pequeno conjunto de tags. O código Java é delimitado por <% e %>. É importante ter em mente que cada página JSP é convertida em um servlet antes da execução. O processo segue um raciocínio bastante simples: o que está dentro dos tags é código Java e, portanto, copiado integralmente para o programa (servlet) gerado; o HTML é também copiado, mas cada linha de HTML é reescrita em código da forma: out.println ("<HTML> ....").

Os demais tags são para definição de objetos Java com tempo de vida que se expande além de uma página, por exemplo durante uma seção inteira, e para chamar métodos get/set de objetos definidos a partir de parâmetros recebidos pela página. Tags estes que são muito convenientes, pois o procedimento padrão descrito ao longo deste texto passa por utilizar tais métodos (em função de argumentos recebidos) para acesso e inserção de dados da classe Pesquisa. Um tag também muito utilizado é <%= e %>., que permite incluir no HTML o resultado de uma expressão Java, tipicamente o resultado de alguma consulta a um objeto, usando o método getXXX().

6.1. Preparação do Ambiente

Antes que se possa usar JSP é necessário instalar um servidor WEB, e um servidor JSP (que inclui um servet engine). Muitos servidores JSP já incorporam um servidor WEB, de modo que para o desenvolver é suficiente ter um servidor.

O processamento de uma página JSP consta dos seguintes passos: 1.O servidor WEB recebe um pedido de uma página com extensão .jsp; 2. Um Servidor JSP é ativado para converter a página em um servlet. A conversão só acontece uma vez, a menos que a página JSP tenha sido modificada desde a última conversão. 3. O servlet gerado é ativado e lê os parâmetros passados à página; JSP oferece um mecanismo simplificado de obter tais parâmetros. 4. O servet gera código HTML e, usando o comando out.println() o devolve ao servidor WEB. 5. O servidor WEB devolve código HTML ao browser cliente.

O NetBeans 3.5, usado no desenvolvimento destes exemplos, tem um servidor JSP (tomcat) embutido. Executar um arquivo .jsp no NetBeans é muito simples, bastando clicar no botão executar, com o arquivo selecionado. Esta ação instancia ambos, o servidor JSP e um browser, sendo os resultados apresentados em seguida. As mensagens de erros emitidas pelo tomcat dizem muito pouco ao desenvolvedor, sendo preferível, em muitos casos, usar o servidor Resin (http://www.caucho.com/).

6.2. As Páginas JSP

São três as páginas: uma principal com um formulário de consulta (JSPPesquisa.jsp), uma de inserção de dados (JSPIncluir.jsp) e outra de apresentação do resultado da consulta (JSPConsultar.jsp). Abaixo a visualização da página principal:

O link de inserção está assim especificado - http://127.0.0.1/JSPIncluir.jsp?acao=3. Para a consulta, o formulário está assim definido:

<form method=POST action="JSPConsultar.jsp?acao=1"> Nome: <input type=text name="nome" size=20> <input type=submit value="Ok"> <input type=reset value="Limpar"> </form>

A página resultante de uma consulta colocando o nome Galileu no formulário principal é o seguinte:

O Código relevante de JSPConsultar.jsp é:

..... <body> <%@ page import = "Pesquisa" %> <jsp:useBean id="p1" scope="page" class="Pesquisa" /> <jsp:setProperty name="p1" property="*" /> <% p1.fazAcao(); %> <h1> Resultado de Pesquisa </h1> Nome: <jsp:getProperty name="p1" property="nome" /> <br> Fone: <jsp:getProperty name="p1" property="fone" /> <br> Celular: <jsp:getProperty name="p1" property="celular" /> <br> Email: <jsp:getProperty name="p1" property="email" /> <br> <table> <tr> <td></td> <td>Interesse</td> <td>Disponibilidade</td> </tr> <tr> <td>Mod1</td> <td><jsp:getProperty name="p1" property="intmod1" /></td> <td><jsp:getProperty name="p1" property="dispmod1" /></td> .....

A primeira tag JSP é para indicar que neste arquivo será utilizada uma classe cujo nome é Pesquisa. Se mais de uma existir pode repetir a tag ou simplesmente usar várias classes separadas por "," . A segunda tag cria um objeto, nominado de p1, da classe Pesquisa, com validade apenas nesta página. Neste caso particular poder-se-ia trocar este código por: <% Pesquisa p1 = new Pesquisa(); %>.

A tag <jsp:setProperty name="p1" property="*" /> é muito importante. Seu objetivo é analisar cada um dos parâmetros de entrada e para aqueles que têm o mesmo nome de algum atributo do objeto p1, será chamado um respectivo método p1.setXXX(). No exemplo, dois atributos são passados pelo formulário que chama a página JSPConsultar.jsp, acao=1 e nome="Galileu". Como p1 tem os métodos setAcao e setNome, estes serão chamados, recebendo os valores dos parâmetros recebidos pela página. Finalmente, o método p1.fazAcao() é executado, significando que será feita uma busca no BD, pelo nome de "Galileu".

As próximas tags seguem um mesmo formato: <jsp:getProperty name="p1" property="fone"/>. Neste caso o tag é equivalente ao código <%= p1.getFone() %>, significando que o valor do campo fone será consultado e emitido no HTML. Mister não ignorar o padrão de nomeação de campos e métodos nas classes em que as tags: getProperty e setProperty são utilizadas. Veja a seção 3.2 para os detalhes.

Resta analisar a página JSPIncluir.jsp, cuja aparência visual pode ser vista abaixo:

O Código relevante de JSPIncluir.jsp, chamado inicialmente com o parâmetro acao=3, é:

..... <body> <%@ page import = "Pesquisa" %> <jsp:useBean id="p2" scope="session" class="Pesquisa" /> <jsp:setProperty name="p2" property="*" /> <% p2.fazAcao(); %> <center> <H1> Formulario de Pesquisa </H1> <form method=POST action="JSPIncluir.jsp?acao=2"> Nome: <input type=text name="nome" size=40> <br> Fone: <input type=text name="fone" size=40> <br> Celular: <input type=text name="celular" size=40> <br> Email: <input type=text name="email" size=40> <br>

Pouco resta a ser mencionado sobre este código. Quando chamado inicialmente tem o impacto de promover uma limpeza nos atributos do objeto p2, pois fazAcao encontrará o valor de acao=3, resultante do primeiro setProperty. Para fazer a inclusão, o formulário chama a si mesmo, observe o valor de action, mas neste caso com acao=2. Nesta segunda chamada, todos os atributos preenchidos no formulário serão enviados para p2 e fazAcao() se encarrega de por os valores do BD.

A exemplo das outras formas de apresentação, não foram consideradas situações de erro.

7. Conclusão

Esta edição é destinada à apresentação de uma metodologia de acesso a Sistemas de Banco de Dados usando diferentes estratégias de apresentação, desde a, assim denominado, modo terminal até WEB Browsers, além daquela baseada em clientes gordos.

Não se trata de uma discussão exaustiva sobre Java, Applets, Aplicações, Servlets ou JSP, mas serve de introdução e contextualização do papel de cada uma destas tecnologias no tocante ao desenvolvimento de aplicações de Bancos de Dados. Procurou-se demonstrar que a apregoada separação entre apresentação e lógica de negócios conduz a um projeto de fácil manutenção e adaptação a novos esquemas de apresentação.