5. Anexos

Descrevemos aqui a instalação e o uso básico das ferramentas utilizadas no documento “Persistência Java 5 na prática”. As informações fornecidas abaixo são as disponíveis em maio de 2007. Elas ficarão obsoletas em breve. Quando isso ocorrer, o leitor deverá seguir procedimentos semelhantes, mas que não serão idênticos. As instalações foram realizadas em um computador com Windows XP Professional.

5.1. Java

Utilizaremos a versão mais recente do Java disponível na Sun [http://www.sun.com]. Os downloads estão disponíveis no endereço [http://java.sun.com/javase/downloads/index.jsp]:

Inicie a instalação do JDK a partir do arquivo baixado. Por padrão, o Java é instalado em [C:\Program Files\Java]:

5.2. Eclipse

5.2.1. Instalação básica

O Eclipse é um IDE disponível no endereço [http://www.eclipse.org/] e pode ser baixado no endereço [http://www.eclipse.org/downloads/]. Abaixo, baixamos o Eclipse 3.2.2:

Depois de baixar o arquivo zip, descompactamos-o em uma pasta no disco:

A partir de agora, chamaremos de <eclipse> a pasta de instalação do Eclipse, acima indicada como [C:\devjava\eclipse 3.2.2\eclipse]. [eclipse.exe] é o executável e [eclipse.ini] é o arquivo de configuração do mesmo. Vamos examinar o conteúdo deste último:

1
2
3

-vmargs
-Xms40m
-Xmx256m

Esses argumentos são utilizados ao iniciar o Eclipse da seguinte maneira:

eclipse.exe -vmargs -Xms40m -Xmx256m

Chegamos ao mesmo resultado obtido com o arquivo .ini, criando um atalho que iniciaria o Eclipse com esses mesmos argumentos. Vamos explicar cada um deles:

-vmargs: indica que os argumentos a seguir são destinados à máquina virtual Java que executará o Eclipse. O Eclipse é um aplicativo Java.
-Xms40m: ?
-Xmx256m: define o tamanho da memória, em MB, alocado à máquina virtual Java (JVM) que executa o Eclipse. Por padrão, esse tamanho é de 256 MB, conforme mostrado aqui. Se a máquina permitir, 512 MB é preferível.

Esses argumentos são passados para o JVM, que executará o Eclipse. O JVM é representado por um arquivo [java.exe] ou [javaw.exe]. Como esse arquivo é localizado? Na verdade, ele é procurado de diferentes maneiras:

no arquivo PATH do OS
na pasta <JAVA_HOME>/jre/bin, onde JAVA_HOME é uma variável de sistema que define a pasta raiz de um JDK.
em um local passado como argumento ao Eclipse na forma -vm <caminho>\javaw.exe

Esta última solução é preferível, pois as outras duas estão sujeitas a imprevistos decorrentes de instalações posteriores de aplicativos, que podem alterar tanto o PATH quanto o OS, ou ainda a variável JAVA_HOME.

Portanto, criamos o atalho a seguir:

`cible`	<eclipse>\eclipse.exe" -vm "C:\Program Files\Java\jre1.6.0_01\bin\javaw.exe" -vmargs -Xms40m -Xmx512m
`Démarrer dans`	pasta <eclipse> de instalação do Eclipse

Feito isso, vamos iniciar o Eclipse por meio deste atalho. Aparece uma primeira caixa de diálogo:

Um [workspace] é um espaço de trabalho. Aceite os valores padrão propostos. Por padrão, os projetos do Eclipse serão criados na pasta <workspace> especificada nesta caixa de diálogo. É possível contornar esse comportamento. É o que faremos sistematicamente. Portanto, a resposta dada nesta caixa de diálogo não é importante.

Após essa etapa, o ambiente de desenvolvimento do Eclipse é exibido:

Fechamos a visualização [Welcome], conforme sugerido acima:

Antes de criar um projeto Java, vamos configurar o Eclipse para indicar o JDK a ser usado para compilar os projetos Java. Para isso, selecionamos a opção [Window / Preferences / Java / Installed JREs ]:

Normalmente, o JRE (Java Runtime Environment) que foi usado para iniciar o próprio Eclipse deve estar presente na lista de JRE. Normalmente, esse será o único. É possível adicionar JREs usando o botão [Add]. Nesse caso, é necessário indicar a raiz do JRE. O botão [Search], por sua vez, iniciará uma busca pelo JREs no disco. Essa é uma boa maneira de saber em que ponto estamos em relação aos JREs que instalamos e depois esquecemos de desinstalar ao atualizar para uma versão mais recente. Acima, o JRE marcado é aquele que será usado para compilar e executar os projetos Java. É o que foi instalado no parágrafo 5.1 e que também serviu para iniciar o Eclipse. Um clique duplo nele dá acesso às suas propriedades:

Agora, vamos criar um projeto Java [File / New / Project]:

Selecione [Java Project] e, em seguida, [Next] ->

Em [2], indicamos uma pasta vazia na qual o projeto Java será instalado. Em [1], atribuímos um nome ao projeto. Ele não precisa ter o mesmo nome da pasta, como o exemplo acima poderia sugerir. Feito isso, usamos o botão [Next] para avançar para a próxima página do assistente de criação:

Acima, criamos uma pasta especial no projeto para armazenar os arquivos-fonte (.java):

em [1], vemos a pasta [src], na qual serão armazenados os arquivos-fonte .java
em [2], vemos a pasta [bin], na qual serão armazenados os arquivos compilados .class

Concluímos o assistente com [Finish]. Temos, então, uma estrutura básica de projeto Java:

Clicamos com o botão direito do mouse no projeto [test1] para criar uma classe Java:

em [1], a pasta onde a classe será criada. O Eclipse sugere, por padrão, a pasta do projeto atual.
em [2], o pacote no qual a classe será colocada
em [3], o nome da classe
em [4], solicitamos que o método estático [main] seja gerado

Confirmamos o assistente por meio de [Finish]. O projeto é então enriquecido com uma classe:

O Eclipse gerou o esboço da classe. Ele pode ser acessado clicando duas vezes em [Test1.java] acima:

Modificamos o código acima da seguinte maneira:

Executamos o programa [Test1.java]: [clic droit sur Test1.java -> Run As -> Java Application]

O resultado da execução é exibido na janela [Console]:

A janela [Console] deve aparecer por padrão. Caso contrário, é possível solicitar sua exibição por meio do [Window/Show View/Console]:

5.2.2. Escolha do compilador

O Eclipse permite gerar código compatível com Java 1.4, Java 1.5 e Java 1.6. Por padrão, ele está configurado para gerar código compatível com Java 1.4. O API e o JPA exigem código Java 1.5. Alteramos o tipo de código gerado pelo [Window / Preferences / Java / Compiler]:

para [1]: escolha da opção [Java / Compiler]
para [2]: escolha da compatibilidade com Java 5.0

5.2.3. Instalação dos plug-ins do Callisto do

A versão básica instalada acima permite criar aplicativos Java de console, mas não aplicativos Java do tipo web ou Swing; caso contrário, é preciso fazer tudo manualmente. Vamos instalar diversos plug-ins:

Procedamos da seguinte forma [Help/Software Udates/Find and Install]:

no [2], indicamos que queremos instalar novos plug-ins

em [3], indicamos os sites a serem explorados para encontrar os plug-ins
em [4], marca-se os plug-ins desejados

em [5], o Eclipse avisa que foi escolhido um plugin que depende de outros plugins que não foram selecionados
em [6], usa-se o botão [Select Required] para selecionar automaticamente os plug-ins que faltam
em [7], aceita-se os termos das licenças desses diversos plug-ins

em [8], é exibida a lista de todos os plug-ins que serão instalados
em [9], inicia-se o download desses plug-ins
em [10], uma vez baixados, todos eles são instalados sem verificar suas assinaturas

em [11], ao final da instalação dos plug-ins, deixamos o Eclipse reiniciar
em [12]; se executarmos o [File/New/Project], descobrimos que agora é possível criar aplicativos web, o que não era possível inicialmente.

5.2.4. Instalação do plug-in [TestNG]

O TestNG (Test Next Generation) é uma ferramenta de testes unitários semelhante, em sua essência, ao JUnit. No entanto, ele traz melhorias que nos levam a preferi-lo aqui ao JUnit. Procedemos da mesma forma que anteriormente: [Help/Software Udates/Find and Install]:

no [2], indicamos que queremos instalar novos plug-ins

em [3a], o site de download de [TestNG] não está presente. Nós o adicionamos com [3b]
em [4b]: o site do plugin é [http://beust.com/eclipse]. Em [4a], colocamos o que quisermos.

em [5a], o plugin [TestNG] está selecionado para a atualização. Em [5b], iniciamos a atualização.
Em [6], a conexão com o site do plugin foi estabelecida. São exibidos todos os plugins disponíveis no site. Aqui, selecionamos apenas um antes de passar para a próxima etapa.

em [7], aceitamos os termos da licença do plugin
em [8], temos a lista de todos os plug-ins que serão instalados; selecionamos um aqui. Iniciamos o download. Em seguida, tudo ocorre conforme descrito acima, para os plug-ins do Callisto.

Depois que o Eclipse for reiniciado, é possível verificar a presença do novo plug-in solicitando, por exemplo, a exibição das visualizações disponíveis [Window / show View / Other]:

Vemos acima a existência de uma visualização [TestNG] que não existia anteriormente.

5.2.5. Instalação do plug-in [Hibernate Tools]

O Hibernate é um provedor JPA, e o plug-in [Hibernate Tools] para o Eclipse é útil na criação de aplicativos JPA. Em maio de 2007, apenas sua versão mais recente (3.2.0beta9) permite trabalhar com o Hibernate/JPA, e ela não está disponível por meio do mecanismo descrito acima. Apenas as versões mais antigas estão disponíveis. Portanto, vamos proceder de maneira diferente.

O plug-in está disponível no site do Hibernate Tools: http://tools.hibernate.org/.

em [1], seleciona-se a versão mais recente do Hibernate Tools
em [2], faz-se o download

em [3], com um programa de descompactação, descompacte na pasta <eclipse> o arquivo zip baixado (é preferível que o Eclipse não esteja em execução)
em [4], aceita-se que alguns arquivos sejam sobrescritos durante a operação

Reinicie o Eclipse:

em [1]: abra uma perspectiva
em [2]: agora existe uma perspectiva [Hibernate Console]

Não vamos prosseguir com o plugin [Hibernate Tools] (Cancel em [2]). Sua forma de uso é explicada nos exemplos do tutorial.

Às vezes, o Eclipse não detecta a presença de novos plug-ins. É possível forçá-lo a verificar novamente todos os seus plug-ins com a opção -clean. Assim, o executável do atalho do Eclipse seria modificado da seguinte forma:


"<eclipse>\eclipse.exe" -clean -vm "C:\Program Files\Java\jre1.6.0_01\bin\javaw.exe" -vmargs -Xms40m -Xmx512m

Assim que os novos plug-ins forem detectados pelo Eclipse, remova a opção -clean acima.

5.2.6. Instalação do plug-in [SQL Explorer]

Agora vamos instalar um plug-in que nos permitirá explorar o conteúdo de um banco de dados diretamente a partir do Eclipse. Os plug-ins disponíveis para o Eclipse podem ser encontrados no site [http://eclipse-plugins.2y.net/eclipse/plugins.jsp]:

em [1]: o site dos plug-ins do Eclipse
em [2]: selecione a categoria [Database]
em [3]: na categoria [Database], selecione a exibição por classificação (pouco confiável, devido ao baixo número de pessoas que votam)
em [4]: QuantumDB aparece em 1º lugar
em [5]: escolhemos SQLExplorer, mais antigo, com classificação inferior (3º), mas ainda assim muito bom. Acessamos o site do plugin [plugin-homepage]

em [6] e [7]: procedemos ao download do plugin.

e [8]: descompacte o arquivo zip do plug-in na pasta do Eclipse.

Para verificar, reinicie o Eclipse, eventualmente com a opção -clean:

em [1]: abra uma nova perspectiva
em [2]: vemos que uma perspectiva [SQL Explorer] está disponível. Voltaremos a isso mais tarde.

5.3. O contêiner de servlets Tomcat 5.5

5.3.1. Instalação

Para executar servlets, precisamos de um contêiner de servlets. Apresentamos aqui um deles, o Tomcat 5.5, disponível no endereço http://tomcat.apache.org/. Apresentamos aqui o procedimento (maio de 2007) para instalá-lo. Se uma versão anterior do Tomcat já estiver instalada, é recomendável removê-la antes.

Para baixar o produto, siga o link [Tomcat 5.x] acima:

Pode-se escolher o arquivo .exe destinado à plataforma Windows. Após o download, inicie a instalação do Tomcat clicando duas vezes no arquivo:

Aceite os termos da licença ->

Execute [next] ->

Aceitar a pasta de instalação sugerida ou alterá-la com [Browse] ->

Definir o login e a senha do administrador do servidor Tomcat. Aqui, definimos [admin / admin] ->

O Tomcat 5.x requer o JRE 1.5. Normalmente, ele deve localizar a versão instalada em seu computador. Acima, o caminho indicado é o do JRE 1.6 baixado no parágrafo 5.1. Se nenhum JRE for encontrado, especifique sua raiz usando o botão [1]. Feito isso, use o botão [Install] para instalar o Tomcat 5.x ->

O botão [Finish] conclui a instalação. A presença do Tomcat é indicada por um ícone à direita na barra de tarefas do Windows:

Um clique com o botão direito desse ícone dá acesso aos comandos Iniciar – Parar do servidor:

Usamos a opção [Stop service] para desligar o servidor web agora:

Observe a mudança de estado do ícone. Este pode ser removido da barra de tarefas:

A instalação do Tomcat foi realizada na pasta escolhida pelo usuário, que doravante chamaremos de <tomcat>. A estrutura de pastas dessa pasta para a versão Tomcat 5.5.23 baixada é a seguinte:

A instalação do Tomcat criou alguns atalhos no menu [Démarrer]. Usamos o link [Monitor] abaixo para iniciar a ferramenta de parada/inicialização do Tomcat:

Encontramos então o ícone apresentado anteriormente:

O monitor do Tomcat pode ser ativado clicando duas vezes neste ícone:

Os botões [Start - Stop - Pause] - Restart permitem iniciar, parar e reiniciar o servidor. Iniciamos o servidor com [Start] e, em seguida, acessamos a URL http://localhost:8080 em um navegador. Devemos obter uma página semelhante à seguinte:

É possível seguir os links abaixo para verificar se o Tomcat foi instalado corretamente:

Todos os links da página [http://localhost:8080] são interessantes, e o leitor é convidado a explorá-los. Teremos a oportunidade de voltar aos links que permitem gerenciar as aplicações web implantadas no servidor:

5.3.2. Implantação de uma aplicação web no servidor Tomcat

5.3.3. Implantação

Uma aplicação web deve seguir certas regras para ser implantada em um contêiner de servlets. Seja <webapp> a pasta de uma aplicação web. Uma aplicação web é composta por:

`classes`	na pasta <webapp>\WEB-INF\classes
`archives java`	na pasta <webapp>\WEB-INF\lib
`vues, ressources (.jsp, .html, ...)`	na pasta <webapp> ou em subpastas

O aplicativo web é configurado por um arquivo XML: <webapp>\WEB-INF\web.xml. Esse arquivo não é necessário em casos simples, especialmente quando a aplicação web contém apenas arquivos estáticos. Vamos criar o seguinte arquivo HTML:

<html>
    <head>
      <title>Application exemple</title>
  </head>
  <body>
      Application exemple active ....
  </body>
</html>

e vamos salvá-lo em uma pasta:

Se carregarmos esse arquivo em um navegador, obteremos a seguinte página:

O código URL exibido pelo navegador mostra que a página não foi servida por um servidor web, mas carregada diretamente pelo navegador. Agora, queremos que ela fique disponível por meio do servidor web Tomcat.

Voltemos à estrutura de diretórios do <tomcat>:

A configuração das aplicações web implantadas no servidor Tomcat é feita por meio de arquivos XML localizados na pasta [<tomcat>\conf\Catalina\localhost]:

Esses arquivos XML podem ser criados manualmente, pois sua estrutura é simples. Em vez de seguir esse procedimento, vamos utilizar as ferramentas da web oferecidas pelo Tomcat.

5.3.4. Administração do Tomca

Na página inicial http://localhost:8080, o servidor oferece links para sua administração:

O link [Tomcat Administration] nos permite configurar os recursos que o Tomcat disponibiliza para as aplicações web implantadas nele, por exemplo, um pool de conexões a um banco de dados. Vamos acessar o link:

A página exibida indica que a administração do Tomcat 5.x requer um pacote específico chamado “admin”. Voltemos ao site do Tomcat [http://tomcat.apache.org/download-55.cgi]:

Vamos baixar o arquivo zip chamado [Administration Web Application] e, em seguida, descompactá-lo. Seu conteúdo é o seguinte:

A pasta [admin] deve ser copiada para [<tomcat>\server\webapps], onde <tomcat> é a pasta em que o Tomcat 5.x foi instalado:

A pasta [localhost] contém um arquivo [admin.xml] que deve ser copiado para [<tomcat>\conf\Catalina\localhost]:

Vamos parar e reiniciar o Tomcat, caso ele estivesse em execução. Em seguida, usando um navegador, acessemos novamente a página inicial do servidor web:

Acesse o link [Tomcat Administration]. Aparecerá uma página de login (para que ela seja exibida, pode ser necessário atualizar a página):

Aqui, é preciso inserir novamente as informações que fornecemos durante a instalação do Tomcat. No nosso caso, inserimos o par admin / admin. O botão [Login] nos leva à página seguinte:

Essa página permite que o administrador do Tomcat defina

fontes de dados (Data Sources),
as informações necessárias para o envio de e-mails (Mail Sessions),
dados de ambiente acessíveis a todas as aplicações (Entries de ambiente),
gerenciar usuários/administradores do Tomcat (Users),
gerenciar grupos de usuários (Groups),
definir funções (= o que um usuário pode ou não fazer),
definir as características das aplicações web implantadas pelo servidor (Service Catalina)

Vamos acessar o link [Roles] acima:

Uma função permite definir o que um usuário ou um grupo de usuários pode ou não fazer. A uma função são associados determinados direitos. Cada usuário está associado a uma ou mais funções e dispõe dos direitos correspondentes a elas. A função [manager] abaixo concede o direito de gerenciar as aplicações web implantadas no Tomcat (implantação, inicialização, desligamento, descarregamento). Vamos criar um usuário [manager], ao qual associaremos a função [manager] para permitir que ele gerencie as aplicações do Tomcat. Para isso, seguimos o link [Users] na página de administração:

Vemos que já existe um certo número de usuários. Utilizamos a opção [Create New User] para criar um novo usuário:

Atribuímos ao usuário “manager” a senha “manager” e a função “manager”. Utilizamos o botão [Save] para confirmar essa adição. O novo usuário aparece na lista de usuários:

Esse novo usuário será adicionado ao arquivo [<tomcat>\conf\tomcat-users.xml]:

cujo conteúdo é o seguinte:

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="role1" password="tomcat" roles="role1"/>
  <user username="both" password="tomcat" roles="tomcat,role1"/>
  <user username="manager" password="manager" fullName="" roles="manager"/>
  <user username="admin" password="admin" roles="admin,manager"/>
</tomcat-users>

linha 10: o usuário [manager] que foi criado

Outra maneira de adicionar usuários é editar diretamente esse arquivo. É assim que se deve proceder, especialmente se, por acaso, você tiver esquecido a senha do administrador “admin” ou do “manager”.

5.3.5. Gerenciamento de aplicativos web implantados

Voltemos agora à página inicial [http://localhost:8080] e sigamos o link [Tomcat Manager]:

Chegamos então a uma página de autenticação. Fazemos o login como “manager / manager”, c.a.d, o usuário com a função [manager] que acabamos de criar. De fato, somente um usuário com essa função pode utilizar esse link. Na linha 11 de [tomcat-users.xml], vemos que o usuário [admin] também possui a função [manager]. Portanto, também poderíamos utilizar a autenticação [admin / admin].

Obtemos uma página que lista as aplicações atualmente implantadas no Tomcat:

Podemos adicionar uma nova aplicação por meio dos formulários localizados na parte inferior da página:

Aqui, queremos implantar no Tomcat a aplicação de exemplo que criamos anteriormente. Fazemos isso da seguinte maneira:

`Context Path`	/exemplo	o nome usado para designar o aplicativo web a ser implantada
`Directory URL`	C:\data\trabalho\2006-2007\eclipse\dvp-jpa\anexos\tomcat\exemplo	a pasta da aplicação web

Para obter o arquivo [C:\data\travail\2006-2007\eclipse\dvp-jpa\annexes\tomcat\exemple\exemple.html], solicitaremos ao Tomcat o URL e o [http://localhost:8080/exemple/exemple.html]. O contexto serve para atribuir um nome à raiz da árvore de diretórios da aplicação web implantada. Utilizamos o botão [Deploy] para realizar a implantação da aplicação. Se tudo correr bem, obtemos a seguinte página de resposta:

e a nova aplicação aparece na lista de aplicações implantadas:

Vamos comentar a linha do contexto /exemplo acima:

`/exemple`	link para http://localhost:8080/exemple
`Démarrer`	permite iniciar o aplicativo
`Arrêter`	permite encerrar o aplicativo
`Recharger`	permite recarregar o aplicativo. Isso é necessário, por exemplo, quando se adicionou, alterado ou excluído determinadas classes do aplicativo.
`Undeploy`	exclusão do contexto [/exemple]. O aplicativo desaparece da lista de aplicativos disponíveis.

Agora que nossa aplicação /exemplo está implantada, podemos realizar alguns testes. Acessamos a página [exemple.html] por meio da URL [http://localhost:8080/exemple/vues/exemple.html]:

Outra maneira de implantar um aplicativo web no servidor Tomcat é inserir as informações que fornecemos pela interface web em um arquivo [contexte].xml, localizado na pasta [<tomcat>\conf\Catalina\localhost], onde [contexte] é o nome do aplicativo web.

Voltemos à interface de administração do Tomcat:

Vamos excluir a aplicação [/exemple] junto com seu link [Undeploy]:

A aplicação [/exemple] não faz mais parte da lista de aplicações ativas. Agora, vamos definir o seguinte arquivo [exemple.xml]:

1 2	`<Context docBase="C:/data/travail/2006-2007/eclipse/dvp-jpa/annexes/tomcat/exemple"> </Context>`

O arquivo XML é composto por uma única tag <Context>, cujo atributo docBase define a pasta que contém a aplicação web a ser implantada. Vamos colocar esse arquivo em <tomcat>\conf\Catalina\localhost:

Vamos parar e reiniciar o Tomcat, se necessário, e, em seguida, visualizar a lista de aplicativos ativos com o gerenciador do Tomcat:

A aplicação [/exemple] está presente. Acessemos, em um navegador, a URL:

[http://localhost:8080/exemple/exemple.html]:

Um aplicativo web assim implantado pode ser removido da lista de aplicativos implantados, da mesma forma que anteriormente, usando o link [Undeploy]:

Nesse caso, o arquivo [exemple.xml] é automaticamente removido da pasta [<tomcat>\conf\Catalina\localhost].

Por fim, para implantar um aplicativo web no Tomcat, também é possível definir seu contexto no arquivo [<tomcat>\conf\server.xml]. Não abordaremos esse ponto aqui.

5.3.6. Aplicativo web com página inicial

Quando acessamos a URL [http://localhost:8080/exemple/], obtemos a seguinte resposta:

Em algumas versões anteriores do Tomcat, teríamos obtido o conteúdo da pasta física da aplicação [/exemple].

É possível fazer com que, quando o contexto for solicitado, seja exibida uma página chamada de página inicial. Para isso, criamos um arquivo [web.xml], que colocamos na pasta <exemplo>\WEB-INF, onde <exemplo> é a pasta física do aplicativo web [/exemple]. Esse arquivo é o seguinte:

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

  <display-name>Application Exemple</display-name>
  <description>Application web minimale</description>
    <welcome-file-list>
        <welcome-file>/exemple.html</welcome-file>
    </welcome-file-list>    
</web-app>

linhas 2-5: a tag raiz <web-app> com atributos obtidos por copiar/colar do arquivo [web.xml] do aplicativo [/admin] do Tomcat (<tomcat>/server/webapps/admin/WEB-INF/web.xml).
linha 7: o nome de exibição do aplicativo web. Trata-se de um nome livre, com menos restrições do que o nome de contexto do aplicativo. É possível incluir espaços, por exemplo, o que não é permitido no nome de contexto. Esse nome é exibido, por exemplo, pelo administrador do Tomcat:

linha 8: descrição da aplicação web. Esse texto pode ser obtido posteriormente por meio de programação.
linhas 9-11: a lista de arquivos de boas-vindas. A tag <welcome-file-list> serve para definir a lista de visualizações a serem apresentadas quando um cliente solicita o contexto da aplicação. Pode haver várias visualizações. A primeira encontrada é apresentada ao cliente. Aqui, temos apenas uma: [/exemple.html]. Assim, quando um cliente solicitar a URL [/exemple], na verdade será a URL [/exemple/exemple.html] que lhe será fornecida.

Vamos salvar esse arquivo [web.xml] em <exemplo>\WEB-INF:

Se o Tomcat ainda estiver ativo, é possível forçá-lo a recarregar a aplicação web [/exemple] usando o link [Recharger]:

Durante essa operação de “recarregamento”, o Tomcat relê o arquivo [web.xml] contido em [<exemple>\WEB-INF], caso ele exista. Esse será o caso aqui. Se o Tomcat estiver parado, reinicie-o.

Usando um navegador, acessemos o URL e o [http://localhost:8080/exemple/]:

O mecanismo dos arquivos de acolhimento funcionou.

5.3.7. Integração do Tomcat no Eclipse

Agora vamos integrar o Tomcat ao Eclipse. Essa integração permite:

iniciar/parar o Tomcat a partir do Eclipse
desenvolver aplicativos web em Java e executá-los no Tomcat. A integração Eclipse/Tomcat permite rastrear (depurar) a execução do aplicativo, incluindo a execução das classes Java (servlets) executadas pelo Tomcat.

Vamos iniciar o Eclipse e, em seguida, acessar a visualização [Servers]:

em [1]: Window/Show View/Other
em [2]: selecione a visualização [Servers] e execute [OK]

em [1], temos uma nova visualização [Servers]
em [2], clica-se com o botão direito do mouse na visualização e solicita-se a criação de um novo servidor [New/Server]
em [3], selecione o servidor [Tomcat 5.5] e, em seguida, crie [Next]

em [4], indique a pasta de instalação do Tomcat 5.5
em [5], indica-se que não há projetos Eclipse/Tomcat no momento. Executa-se [Finish]

A adição do servidor se concretiza com a inclusão de uma pasta no explorador de projetos do Eclipse [6] e o aparecimento de um servidor na visualização [servers] [7]:

Na visualização [Servers] aparecem todos os servidores declarados; neste caso, apenas o servidor Tomcat 5.5 que acabamos de registrar. Um clique com o botão direito do mouse nele dá acesso aos comandos que permitem iniciar, parar e reiniciar o servidor:

Acima, iniciamos o servidor. Durante a inicialização, vários registros são gravados na visualização [Console]:

16 mai 2007 09:51:57 org.apache.catalina.core.AprLifecycleListener lifecycleEvent
...
16 mai 2007 09:51:57 org.apache.coyote.http11.Http11BaseProtocol init
INFO: Initialisation de Coyote HTTP/1.1 sur http-8080
...
INFO: Find registry server-registry.xml at classpath resource
16 mai 2007 09:51:58 org.apache.catalina.startup.Catalina start
INFO: Server startup in 828 ms

A compreensão desses logs requer certa familiaridade. Não vamos nos aprofundar nesse assunto por enquanto. No entanto, é importante verificar se eles não indicam erros no carregamento de contextos. De fato, ao ser iniciado, o servidor Tomcat/Eclipse tenta carregar o contexto das aplicações que gerencia. Carregar o contexto de uma aplicação implica utilizar seu arquivo [web.xml] e carregar uma ou mais classes que o inicializam. Vários tipos de erros podem ocorrer:

o arquivo [web.xml] está com erros de sintaxe. Esse é o erro mais frequente. Recomenda-se utilizar uma ferramenta capaz de verificar a validade de um documento XML durante sua criação.
algumas classes a serem carregadas não foram encontradas. Elas são procuradas nos arquivos [WEB-INF/classes] e [WEB-INF/lib]. Em geral, é necessário verificar a presença das classes necessárias e a ortografia das classes declaradas no arquivo [web.xml].

O servidor iniciado a partir do Eclipse não tem a mesma configuração que o instalado no parágrafo 5.3. Para ter certeza disso, acessemos a URL [http://localhost:8080] com um navegador:

Essa resposta não indica que o servidor não esteja funcionando, mas que o recurso / solicitado não está disponível. Com o servidor Tomcat integrado ao Eclipse, esses recursos serão projetos web. Veremos isso mais adiante. Por enquanto, vamos parar o Tomcat:

O modo de funcionamento anterior pode ser alterado. Voltemos à visualização [Servers] e cliquemos duas vezes no servidor Tomcat para acessar suas propriedades:

1

A caixa de seleção [1] é responsável pelo modo de funcionamento anterior. Quando marcada, as aplicações web desenvolvidas no Eclipse não são declaradas nos arquivos de configuração do servidor Tomcat associado, mas em arquivos de configuração separados. Dessa forma, não se tem acesso às aplicações definidas por padrão no servidor Tomcat: [admin] e [manager], que são duas aplicações úteis. Portanto, vamos desmarcar [1] e reiniciar o Tomcat:

Feito isso, vamos acessar a URL [http://localhost:8080] em um navegador:

Encontramos aqui o funcionamento descrito no parágrafo 5.3.4.

Em nossos exemplos anteriores, utilizamos um navegador externo ao Eclipse. Também é possível utilizar um navegador interno ao Eclipse:

Selecionamos acima o navegador interno. Para iniciá-lo a partir do Eclipse, pode-se usar o seguinte ícone:

O navegador efetivamente iniciado será aquele selecionado pela opção [Window -> Web Browser]. Aqui, obtemos o navegador interno:

1

Se necessário, inicie o Tomcat a partir do Eclipse e solicite, em [1], a URL [http://localhost:8080]:

Vamos acessar o link [Tomcat Manager]:

É solicitado o par [login / mot de passe] necessário para acessar o aplicativo [manager]. De acordo com a configuração do Tomcat que fizemos anteriormente, podemos digitar [admin / admin] ou [manager / manager]. Assim, obtemos a lista das aplicações implantadas:

5.4. O SGBD a o Firebird

5.4.1. SGBD Firebird

O SGBD Firebird está disponível no URL [http://www.firebirdsql.org/]:

no [1]: utiliza-se a opção [Download.Firebird Relational Database]
em [2]: especifica-se a versão desejada do Firebird
em [3]: baixa-se o arquivo binário de instalação

Depois que o arquivo [3] for baixado, clique duas vezes nele para instalar o Firebird SGBD. O SGBD é instalado em uma pasta cujo conteúdo é semelhante ao seguinte:

Os arquivos binários estão na pasta [bin]:

`fbguard.exe`	permite iniciar/parar o SGBD
`isql.exe`	cliente de linha que permite gerenciar bancos de dados

Observe que, por padrão, o administrador do SGBD se chama [SYSDBA] e sua senha é [masterkey]. Foram instalados menus no [Démarrer]:

A opção [Firebird Guardian] permite iniciar/encerrar o SGBD. Após o início, o ícone do SGBD permanece na barra de tarefas do Windows:

Para criar e utilizar bancos de dados Firebird com o cliente de linha de comando [isql.exe], é necessário consultar a documentação fornecida com o produto, acessível por meio dos atalhos do Firebird no [Démarrer/Programmes/Firebird 2.0].

Uma maneira rápida de trabalhar com o Firebird e aprender a linguagem SQL é utilizar um cliente gráfico. Um exemplo desse tipo de cliente é o IB-Expert, descrito no parágrafo a seguir.

5.4.2. Trabalhando com o SGBD Firebird com o IB- Expert

O site principal do IB-Expert é [http://www.ibexpert.com/].

em [1], selecione IBExpert
em [2], seleciona-se o download após, se desejar, escolher o idioma de sua preferência
em [3], seleciona-se a versão chamada “pessoal”, pois é gratuita. No entanto, é necessário se cadastrar no site.
em [4], baixe o IBExpert

O IBExpert é instalado em uma pasta semelhante à seguinte:

O executável é o [ibexpert.exe]. Normalmente, há um atalho disponível no menu [Démarrer]:

Uma vez iniciado, o IBExpert exibe a seguinte janela:

Vamos usar a opção [Database/Create Database] para criar um banco de dados:

`Server (Serveur)`	pode ser [local] ou [remote]. Aqui, nosso servidor está na mesma máquina que o [IBExpert]. Escolhemos , portanto, [local]
`Database (Base de données)`	usar o botão do tipo [dossier] do menu suspenso para indicar o arquivo do banco de dados. O Firebird coloca toda a base em um único arquivo. Essa é uma de suas vantagens. A base de dados é transferida de um computador para outro simplesmente copiando o arquivo. O sufixo [.fdb] é adicionado automaticamente.
`Username`	SYSDBA é o administrador padrão das distribuições atuais do Firebird
`Password (Nom de l'utilisateur)`	masterkey é a senha do administrador SYSDBA das distribuições atuais do Firebird
`Dialect`	o dialeto SQL a ser utilizado
`Register Database (Référencer la base de données)`	se a caixa estiver marcada, o IBExpert exibirá um link para o banco de dados criado após sua criação

Se, ao clicar no botão de criação [OK], você receber o seguinte aviso:

isso significa que você não iniciou o Firebird. Inicie-o. Aparecerá uma nova janela:

Charset
(Jeu de caractères)

Família de caracteres a ser usada. Recomenda-se selecionar na lista suspensa a família

[ISO-8859-1], que permite usar caracteres latinos acentuados.

Server version
(Version du serveur)

[IBExpert] é capaz de gerenciar diferentes SGBD derivados do Interbase.

Selecione a versão do Firebird que você instalou.

Depois que essa nova janela for validada pelo [Register], obtém-se o resultado [1] na janela [Database Explorer]. Essa janela pode ser fechada acidentalmente. Para recuperá-la, execute o [2]:

Para acessar o banco de dados criado, basta clicar duas vezes no link correspondente. O IBExpert exibe então uma árvore de navegação que dá acesso às propriedades do banco de dados:

5.4.3. Criação de uma tabela de dados

Vamos criar uma tabela. Clique com o botão direito do mouse em [Tables] (veja a janela acima) e selecione a opção [New Table]. Aparecerá a janela de definição das propriedades da tabela:

Vamos começar atribuindo o nome [ARTICLES] à tabela, utilizando o campo de entrada [1]:

Usemos o campo de entrada [2] para definir uma chave primária [ID]:

Um campo é definido como chave primária ao clicar duas vezes no campo [PK] (Primary Key) do campo. Vamos adicionar campos usando o botão localizado acima de [3]:

Enquanto não tivermos “compilado” nossa definição, a tabela não será criada. Vamos usar o botão [Compile] acima para concluir a definição da tabela. IBExpert prepara as consultas SQL para a geração da tabela e solicita confirmação:

Curiosamente, o IBExpert exibe as consultas SQL que executou. Isso permite o aprendizado tanto da linguagem SQL quanto do dialeto SQL, que pode ser proprietário. O botão [Commit] permite confirmar a transação em andamento, enquanto o botão [Rollback] permite cancelá-la. Aqui, aceitamos a transação com [Commit]. Feito isso, IBExpert adiciona a tabela criada à estrutura da nossa base de dados:

Ao clicar duas vezes na tabela, temos acesso às suas propriedades:

O painel [Constraints] permite adicionar novas restrições de integridade à tabela. Vamos abri-lo:

Encontramos a restrição de chave primária que criamos. É possível adicionar outras restrições:

chaves estrangeiras [Foreign Keys]
restrições de integridade de campos [Checks]
restrições de exclusividade de campos [Uniques]

Observemos que:

os campos [ID, PRIX, STOCKACTUEL, STOKMINIMUM] devem ser >0
o campo [NOM] deve ser diferente de vazio e único

Abramos o painel [Checks] e cliquemos com o botão direito do mouse na área de definição de restrições para adicionar uma nova restrição:

Vamos definir as restrições desejadas:

Observe-se acima que a restrição [NOM<>''] utiliza dois apóstrofos e não aspas. Vamos compilar essas restrições com o botão [Compile] acima:

Mais uma vez, IBExpert demonstra clareza ao indicar as consultas SQL que executou. Passemos agora ao painel [Constraints/Uniques] para indicar que o nome deve ser único. Isso significa que não é possível ter dois nomes iguais na tabela.

Vamos definir a restrição:

Em seguida, vamos compilá-la. Feito isso, abramos o painel [DDL] (Data Definition Language) da tabela [ARTICLES]:

Esse painel fornece o código SQL para a geração da tabela com todas as suas restrições. É possível salvar esse código em um script para executá-lo posteriormente:

SET SQL DIALECT 3;
SET NAMES ISO8859_1;
CREATE TABLE ARTICLES (
    ID            INTEGER NOT NULL,
    NOM           VARCHAR(20) NOT NULL,
    PRIX          DOUBLE PRECISION NOT NULL,
    STOCKACTUEL   INTEGER NOT NULL,
    STOCKMINIMUM  INTEGER NOT NULL
);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_ID check (ID>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_PRIX check (PRIX>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKACTUEL check (STOCKACTUEL>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKMINIMUM check (STOCKMINIMUM>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_NOM check (NOM<>'');
ALTER TABLE ARTICLES ADD CONSTRAINT UNQ_NOM UNIQUE (NOM);
ALTER TABLE ARTICLES ADD CONSTRAINT PK_ARTICLES PRIMARY KEY (ID);

5.4.4. Inserção de dados em uma tabela

Agora é hora de inserir dados na tabela [ARTICLES]. Para isso, vamos usar seu painel [Data]:

Os dados são inseridos clicando duas vezes nos campos de entrada de cada linha da tabela. Uma nova linha é adicionada com o botão [+], e uma linha é excluída com o botão [-]. Essas operações são realizadas em uma transação que é validada pelo botão [Commit Transaction] (veja acima). Sem essa validação, os dados serão perdidos.

5.4.5. O editor SQL de [IB-Expert]

A linguagem SQL (Structured Query Language) permite que um usuário:

criar tabelas, especificando o tipo de dados que elas armazenarão e as restrições que esses dados devem cumprir
inserir dados nelas
modificar alguns dados
excluir outras
explorar o conteúdo para obter informações
...

O IBExpert permite que um usuário realize as operações de 1 a 4 de forma gráfica. Acabamos de ver isso. Quando o banco de dados contém muitas tabelas, cada uma com centenas de linhas, precisamos de informações difíceis de obter visualmente. Suponhamos, por exemplo, que uma loja virtual na internet tenha milhares de compradores por mês. Todas as compras são registradas em um banco de dados. Após seis meses, descobre-se que um produto “X” apresenta defeito. Deseja-se entrar em contato com todas as pessoas que o compraram para que devolvam o produto para uma troca gratuita. Como encontrar os endereços desses compradores?

É possível consultar visualmente todas as tabelas e procurar esses compradores. Isso levará algumas horas.
É possível emitir uma ordem SQL que fornecerá a lista dessas pessoas em poucos segundos

A linguagem SQL é útil sempre que

quando a quantidade de dados nas tabelas é grande
quando há muitas tabelas interligadas
quando as informações a serem obtidas estão distribuídas por várias tabelas
...

Apresentamos agora o editor SQL do IBExpert. Ele pode ser acessado por meio da opção [Tools/SQL Editor] ou [F12]:

Assim, temos acesso a um editor avançado de consultas SQL, com o qual podemos testar consultas. Digite uma consulta:

Executamos a consulta SQL usando o botão [Execute] acima. Obtemos o seguinte resultado:

Acima, a aba [Results] apresenta a tabela de resultados da ordem SQL [Select]. Para emitir um novo comando SQL, basta voltar à aba [Edit]. Encontramos então a ordem SQL, que já foi executada.

Vários botões da barra de ferramentas são úteis:

o botão [New Query] permite passar para uma nova consulta SQL:

Assim, obtém-se uma página de edição em branco:

É possível, então, inserir um novo pedido SQL:

e executá-la:

Voltemos à aba [Edit]. As diferentes ordens SQL emitidas são armazenadas por [IBExpert]. O botão [Previous Query] permite retornar a uma ordem SQL emitida anteriormente:

Retorna-se, então, à consulta anterior:

O botão [Next Query] permite, por sua vez, avançar para a ordem seguinte, SQL:

Encontramos então a ordem SQL, que vem a seguir na lista de ordens SQL armazenadas:

O botão [Delete Query] permite excluir uma ordem SQL da lista de ordens armazenadas:

O botão [Clear Current Query] permite limpar o conteúdo do editor para a ordem SQL exibida:

O botão [Commit] permite confirmar definitivamente as alterações feitas no banco de dados:

O botão [RollBack] permite desfazer as alterações feitas no banco de dados desde o último [Commit]. Se nenhum [Commit] tiver sido executado desde a conexão com o banco de dados, serão desfeitas as alterações feitas a partir dessa conexão.

Vejamos um exemplo. Vamos inserir uma nova linha na tabela:

O comando SQL é executado, mas nada é exibido. Não sabemos se a inserção ocorreu. Para descobrir, vamos executar o comando SQL após o [New Query]:

O resultado obtido com o [Execute] é o seguinte:

Portanto, a linha foi inserida corretamente. Vamos agora examinar o conteúdo da tabela de outra maneira. Clique duas vezes na tabela [ARTICLES] no explorador de bancos de dados:

Obtemos a seguinte tabela:

O botão com seta acima permite atualizar a tabela. Após a atualização, a tabela acima não sofre alterações. Parece que a nova linha não foi inserida. Voltemos ao editor SQL (F12) e, em seguida, confirmemos a ordem SQL emitida com o botão [Commit]:

Feito isso, voltemos à tabela [ARTICLES]. Podemos constatar que nada mudou, mesmo ao usar o botão [Refresh]:

Acima, vamos abrir a aba [Fields] e, em seguida, voltar à aba [Data]. Desta vez, a linha inserida aparece corretamente:

Quando começa a emissão dos diversos comandos SQL, o editor abre o que é chamado de transação no banco de dados. As modificações feitas por essas ordens SQL do editor SQL só ficarão visíveis enquanto permanecermos no mesmo editor SQL (é possível abrir vários). É como se o editor SQL estivesse trabalhando não no banco de dados real, mas em uma cópia própria. Na realidade, não é exatamente assim que isso ocorre, mas essa imagem pode nos ajudar a compreender o conceito de transação. Todas as alterações feitas na cópia durante uma transação só ficarão visíveis no banco de dados real depois de serem validadas por um [Commit Transaction]. A transação atual é então encerrada e uma nova transação começa.

As alterações feitas durante uma transação podem ser revertidas por meio de uma operação chamada [Rollback]. Vamos fazer o seguinte teste. Iniciemos uma nova transação (basta executar [Commit] na transação atual) com o comando SQL a seguir:

Vamos executar essa ordem, que exclui todas as linhas da tabela [ARTICLES], e, em seguida, executar [New Query], a nova ordem SQL a seguir:

Obtemos o seguinte resultado:

Todas as linhas foram excluídas. Vale lembrar que isso foi feito em uma cópia da tabela [ARTICLES]. Para verificar, cliquemos duas vezes na tabela [ARTICLES] abaixo:

e vamos visualizar a aba [Data]:

Mesmo ao usar o botão [Refresh] ou ao alternar para a aba [Fields] e, em seguida, voltar para a aba [Data], o conteúdo acima permanece inalterado. Isso já foi explicado. Estamos em outra transação que trabalha com sua própria cópia. Agora, voltemos ao editor SQL (F12) e usemos o botão [RollBack] para reverter as exclusões de linhas que foram feitas:

É solicitada uma confirmação:

Vamos confirmar. O editor SQL confirma que as alterações foram revertidas:

Vamos executar novamente a consulta SQL acima para verificar. Encontramos as linhas que haviam sido excluídas:

A operação [Rollback] restaurou a cópia na qual o editor SQL está trabalhando, ao estado em que se encontrava no início da transação.

5.4.6. Exportação de um banco de dados Firebird para um script SQL

Ao trabalhar com diversos SGBD, como é o caso no tutorial “Persistência Java 5 na prática”, é interessante poder exportar um banco de dados de um SGBD 1 para um script SQL para, em seguida, importar este último para um SGBD 2. Isso evita uma série de operações manuais. No entanto, isso nem sempre é possível, pois os arquivos SGBD costumam ter extensões SQL proprietárias.

Vamos mostrar como exportar a base de dados [dbarticles] anterior para um script SQL:

para [1]: Ferramentas / Extrair o MetaData, para extrair os metadados
em [2]: guia Meta Objetos
em [3]: selecione a tabela [Articles] da qual deseja extrair a estrutura (metadados)
em [4]: para transferir para a direita o objeto selecionado à esquerda

em [5]: a tabela [ARTICLES] fará parte dos metadados extraídos
em [6]: a aba [Table de données] serve para selecionar as tabelas cujo conteúdo se deseja extrair (na etapa anterior, era a estrutura da tabela que era exportada)
em [7]: para transferir para a direita o objeto selecionado à esquerda
em [8]: o resultado obtido

em [9]: a aba [Options] permite configurar alguns parâmetros da extração
em [10]: desmarca-se as opções relacionadas à geração das ordens SQL que permitem conectar-se ao banco de dados. Elas são específicas do Firebird e, por isso, não nos interessam.
em [11]: a aba [Sortie] permite especificar onde o script SQL será gerado
em [12]: especifica-se que o script deve ser gerado em um arquivo
em [13]: especifica-se o local desse arquivo
em [14]: inicia-se a geração do script SQL

O script gerado, sem os comentários, é o seguinte:

SET SQL DIALECT 3;
SET NAMES ISO8859_1;

CREATE TABLE ARTICLES (
    ID            INTEGER NOT NULL,
    NOM           VARCHAR(20) NOT NULL,
    PRIX          DOUBLE PRECISION NOT NULL,
    STOCKACTUEL   INTEGER NOT NULL,
    STOCKMINIMUM  INTEGER NOT NULL
);

INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (1, 'article1', 100, 10, 1);
INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (2, 'article2', 200, 20, 2);
INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (3, 'article3', 300, 30, 3);

COMMIT WORK;

ALTER TABLE ARTICLES ADD CONSTRAINT CHK_ID check (ID>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_PRIX check (PRIX>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKACTUEL check (STOCKACTUEL>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKMINIMUM check (STOCKMINIMUM>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_NOM check (NOM<>'');
ALTER TABLE ARTICLES ADD CONSTRAINT UNQ_NOM UNIQUE (NOM);
ALTER TABLE ARTICLES ADD CONSTRAINT PK_ARTICLES PRIMARY KEY (ID);

Observação: as linhas 1 e 2 são específicas do Firebird. Elas devem ser removidas do script gerado para se obter um SQL genérico.

5.4.7. Driver JDBC do Firebird para o ` `

Um programa Java acessa os dados de um banco de dados por meio de um driver JDBC específico para o SGBD utilizado:

Em uma arquitetura multicamadas como a descrita acima, o driver JDBC [1] é utilizado pela camada [dao] (Data Access Object) para acessar os dados de um banco de dados.

O driver JDBC do Firebird está disponível no endereço de onde o Firebird foi baixado:

em [1]: opta-se por baixar o driver JDBC
em [2]: escolhe-se um driver JDBC compatível com o JDK 1.5
em [3]: o arquivo que contém o driver JDBC é o [jaybird-full-2.1.1.jar]. Vamos extrair esse arquivo. Ele será usado para todos os exemplos JPA com o Firebird.

Vamos colocá-lo em uma pasta que chamaremos, a partir de agora, de <jdbc>:

Para verificar esse driver JDBC, usaremos o Eclipse e o plug-in SQL Explorer (parágrafo 5.2.6). Começamos declarando o driver JDBC do Firebird:

no [1]: vá em Window / Preferences
em [2]: selecione a opção SQL Explorer / JDBC Drivers
em [3]: selecione o driver JDBC para o Firebird
em [4]: passar para a fase de configuração
em [5]: acesse a aba [Extra Class Path]
com [6], especificar o arquivo do driver JDBC. Feito isso, ele aparecerá em [7]. Aqui, selecione o driver previamente colocado na pasta <jdbc>
em [8]: o nome da classe Java do driver JDBC. Ele pode ser obtido pelo botão [8b].
Executamos o [OK] para validar a configuração

em [9]: o driver JDBC do Firebird já está configurado. Agora é possível começar a usá-lo.

para [1]: abra uma nova perspectiva
em [2]: selecionar a perspectiva [SQL Explorer]

em [3]: criar uma nova conexão
em [4]: atribuir um nome
em [5]: selecionar na lista suspensa o driver JDBC do Firebird
em [6]: especificar a URL do banco de dados ao qual se deseja se conectar, neste caso: [jdbc:firebirdsql:localhost/3050:C:\data\2006-2007\eclipse\dvp-jpa\annexes\jpa\jpa.fdb]. [jpa.fdb] é o banco de dados criado anteriormente com IBExpert.
em [7]: o nome de usuário da conexão, neste caso [sysdba], o administrador do Firebird
em [8]: sua senha [masterkey]
confirmamos a configuração da conexão por meio de [OK]

em [1]: clica-se duas vezes no nome da conexão que se deseja abrir
em [2]: faça o login (sysdba, masterkey)
em [3]: a conexão está aberta
em [4]: exibe-se a estrutura do banco de dados. Nela, é possível ver a tabela [ARTICLES]. Selecione-a.

em [5]: na janela [Database Detail], são exibidos os detalhes do objeto selecionado em [4], neste caso a tabela [ARTICLES]
em [6]: a aba [Columns] mostra a estrutura da tabela
em [7]: a aba [Preview] apresenta a estrutura da tabela

É possível executar consultas SQL na janela [SQL Editor]:

na [1]: selecione uma conexão aberta
na [2]: digitar o comando SQL a ser executado
em [3]: executá-la
em [4]: resumo do comando executado
em [5]: seu resultado

5.5. O SGBD e o MySQL5

5.5.1. Instalação

O SGBD MySQL5 está disponível no URL [http://dev.mysql.com/downloads/]:

em [1]: escolha a versão desejada
em [2]: escolha uma versão do Windows

em [3]: escolha a versão do Windows desejada
em [4]: o arquivo ZIP baixado contém um executável [Setup.exe] [4b] que deve ser extraído e executado para instalar o MySQL5

em [5]: escolha uma instalação padrão
em [6]: após a conclusão da instalação, é possível configurar o servidor MySQL5

em [7]: escolha uma configuração padrão, aquela que faz menos perguntas
em [8]: o servidor MySQL5 será um serviço do Windows

em [9]: por padrão, o administrador do servidor é o usuário root, sem senha. É possível manter essa configuração ou definir uma nova senha para o usuário root. Se a instalação do MySQL5 ocorrer após a desinstalação de uma versão anterior, essa operação pode falhar. Há poucas maneiras de reverter isso.
em [10]: é solicitada a configuração do servidor

A instalação do MySQL5 cria uma pasta no [Démarrer / Programmes ]:

É possível usar o [MySQL Server Instance Config Wizard] para reconfigurar o servidor:

para [3]: alteramos a senha do usuário root (neste caso, root/root)

5.5.2. Iniciar/Parar o MySQL5

O servidor MySQL5 foi instalado como um serviço do Windows com inicialização automática, sendo que o c.a.d é iniciado assim que o Windows é inicializado. Esse modo de funcionamento é pouco prático. Vamos alterá-lo:

[Démarrer / Panneau de configuration / Performances et maintenance / Outils d'administration / Services ]:

em [1]: clicamos duas vezes em [Services]
em [2]: vemos que existe um serviço chamado [MySQL], que está em execução ([3]) e que sua inicialização é automática ([4]).

Para alterar esse comportamento, clicamos duas vezes no serviço [MySQL]:

em [1]: definimos o serviço para inicialização manual
em [2]: desativamos o serviço
no [3]: confirmamos a nova configuração do serviço

Para iniciar e parar manualmente o serviço MySQL, é possível criar dois atalhos:

em [1]: o atalho para iniciar o MySQL5
e [2]: o atalho para encerrá-lo

5.5.3. Clientes de administração do MySQL

No site do MySQL, é possível encontrar clientes de administração do SGBD:

em [1]: escolha [MySQL GUI Tools], que reúne diversos clientes gráficos que permitem tanto administrar o SGBD quanto utilizá-lo
em [2]: escolha a versão para Windows adequada

em [3]: baixe um arquivo .msi para ser executado
em [4]: após a instalação, novos atalhos aparecem na pasta [Menu Démarrer / Programmes / mySQL].

Vamos executar o MySQL (por meio dos atalhos que você criou) e, em seguida, executar o [MySQL Administrator] pelo menu acima:

em [1]: digite a senha do usuário root (root, neste caso)
no [2]: estamos conectados e vemos que o MySQL está ativo

5.5.4. Criação de um usuário jpa e de um banco de dados jpa

O tutorial utiliza o MySQL5 com um banco de dados chamado jpa e um usuário com o mesmo nome. Vamos criá-los agora. Primeiro, o usuário:

no [1]: selecione o [User Administration]
em [2]: clica-se com o botão direito na parte [User accounts] para criar um novo usuário
em [3]: o usuário se chama jpa e sua senha é jpa
em [4]: confirme a criação
em [5]: o usuário [jpa] aparece na janela [User Accounts]

Agora, o banco de dados:

em [1]: seleção da opção [Catalogs]
em [2]: clique com o botão direito do mouse na janela [Schemata] para criar um novo esquema (que designa um banco de dados)
em [3]: nomeia-se o novo esquema
em [4]: ele aparece na janela [Schemata]

em [5]: seleciona-se o esquema [jpa]
em [6]: os objetos do esquema [jpa] aparecem, incluindo as tabelas. Ainda não há nenhuma. Um clique com o botão direito do mouse permitiria criá-las. Deixamos que o leitor faça isso.

Voltemos ao usuário [jpa] para conceder a ele todos os direitos sobre o esquema [jpa]:

em [1] e, em seguida, em [2]: selecione o usuário [jpa]
em [3]: selecione a aba [Schema Privileges]
em [4]: seleciona-se o esquema [jpa]
em [5]: vamos conceder ao usuário [jpa] todos os privilégios sobre o esquema [jpa]

em [6]: confirmamos as alterações feitas

Para verificar se o usuário [jpa] pode trabalhar com o esquema [jpa], encerramos o administrador MySQL. Reiniciamos o sistema e, desta vez, fazemos login com o nome [jpa/jpa]:

em [1]: fazemos o login (jpa/jpa)
em [2]: a conexão foi bem-sucedida e, em [Schemata], vemos os esquemas sobre os quais temos direitos. Vemos o esquema [jpa].

Agora vamos criar a mesma tabela [ARTICLES] que criamos com o Firebird SGBD, utilizando o script SQL [schema-articles.sql] gerado no parágrafo 5.4.6.

em [1]: use o aplicativo [MySQL Query Browser]
em [2], [3], [4]: fazer login (jpa / jpa / jpa)

em [5]: abrir o script SQL para executá-lo
em [6]: indicar o script [schema-articles.sql] criado no parágrafo 5.4.6.

em [7]: o script carregado
em [8]: ele é executado
em [9]: a tabela [ARTICLES] foi criada

5.5.5. Driver JDBC de MySQL5

O driver JDBC, derivado de MySQL, pode ser baixado no mesmo local que o SGBD:

no [1]: escolha o driver JDBC adequado
no [2]: selecione a versão para Windows adequada
em [3]: no arquivo zip baixado, o arquivo Java que contém o driver JDBC é o [mysql-connector-java-5.0.5-bin.jar]. Vamos extraí-lo para usá-lo nos exemplos do tutorial JPA.

Nós o colocamos da mesma forma que o anterior (parágrafo 5.4.7) na pasta <jdbc>:

Para testar este driver JDBC, utilizaremos o Eclipse e o plug-in SQL Explorer. Recomenda-se ao leitor que siga os passos explicados no parágrafo 5.4.7. Apresentamos algumas capturas de tela relevantes:

no [1]: o arquivo do driver JDBC foi renomeado de MySQL5
em [2]: o driver JDBC, proveniente de MySQL5, está disponível

em [3]: definição da conexão (usuário, senha)=(jpa, jpa)
em [4]: a conexão está ativa
em [5]: a base conectada

5.6. O SGBD o PostgreSQL

5.6.1. Instalação

O SGBD PostgreSQL está disponível no URL [http://www.postgresql.org/download/]:

em [1]: os sites de download do PostgreSQL
em [2]: escolha uma versão para Windows
em [3]: escolher uma versão com instalador

em [4]: o conteúdo do arquivo zip baixado. Clique duas vezes no arquivo [postgresql-8.2.msi]
em [5]: a primeira página do assistente de instalação

em [6]: escolha uma instalação típica, aceitando os valores padrão
em [6b]: criação da conta do Windows que iniciará o serviço PostgreSQL; neste caso, a conta pgres com a senha pgres.

em [7]: permitir que PostgreSQL crie a conta [pgres], caso ela ainda não exista
em [8]: definir a conta de administrador do SGBD, neste caso postgres com a senha postgres

em [9] e [10]: aceite os valores padrão até o final do assistente. O PostgreSQL será instalado.

A instalação do PostgreSQL cria uma pasta no [Démarrer / Programmes ]:

5.6.2. Iniciar/Encerrar o PostgreSQL

O servidor PostgreSQL foi instalado como um serviço do Windows com inicialização automática; o c.a.d é iniciado assim que o Windows é inicializado. Esse modo de funcionamento é pouco prático. Vamos alterá-lo:

[Démarrer / Panneau de configuration / Performances et maintenance / Outils d'administration / Services ]:

em [1]: clicamos duas vezes em [Services]
em [2]: vemos que existe um serviço chamado [PostgreSQL], que está em execução ([3]) e que sua inicialização é automática ([4]).

Para alterar esse comportamento, clicamos duas vezes no serviço [PostgreSQL]:

em [1]: definimos o serviço para inicialização manual
em [2]: desativamos o serviço
no [3]: confirmamos a nova configuração do serviço

Para iniciar e parar manualmente o serviço PostgreSQL, é possível usar os atalhos da pasta [PostgreSQL]:

em [1]: o atalho para iniciar o PostgreSQL
em [2]: o atalho para encerrá-lo

5.6.3. Gerenciar o PostgreSQL

Na captura de tela acima, o aplicativo [pgAdmin III] (3) permite administrar o SGBD e o PostgreSQL. Vamos iniciar o SGBD e, em seguida, o [pgAdmin III] por meio do menu acima:

no [1]: clique duas vezes no servidor PostgreSQL para se conectar a ele
em [2,3]: faça o login como administrador do SGBD, neste caso (postgres / postgres)

no [4]: o único banco de dados existente
em [5]: o único usuário existente

5.6.4. Criação de um usuário jpa e de um banco de dados jpa

O tutorial utiliza PostgreSQL com um banco de dados chamado jpa e um usuário com o mesmo nome. Vamos criá-los agora. Primeiro, o usuário:

no [1]: criamos uma nova função (~usuário)
em [2]: criação do usuário jpa
em [3]: a senha dele é jpa
em [4]: repete-se a senha
no [5]: autoriza-se o usuário a criar bancos de dados
em [6]: o usuário [jpa] aparece entre as funções de conexão

Agora, o banco de dados:

em [1]: cria-se uma nova conexão com o servidor
em [2]: ela se chamará jpa
em [3]: máquina à qual queremos nos conectar
em [4]: o usuário que se conectará
em [5]: sua senha. A configuração da conexão é validada por [OK]
em [6]: a nova conexão foi criada. Ela pertence ao usuário jpa. Este irá agora criar um novo banco de dados:

em [1]: adiciona-se um novo banco de dados
em [2]: seu nome é jpa
em [3]: seu proprietário é o usuário jpa criado anteriormente. A validação é feita por [OK]
em [4]: o banco de dados jpa foi criado. Basta clicar nele para acessá-lo e conhecer sua estrutura:

em [5]: os objetos do esquema [jpa] são exibidos, principalmente as tabelas. Ainda não há nenhuma. Um clique com o botão direito do mouse permitiria criá-las. Deixamos que o leitor faça isso.

Vamos agora criar a mesma tabela [ARTICLES] que criamos com as SGBD anteriores, utilizando o script SQL [schema-articles.sql] gerado no parágrafo 5.4.6.

em [1]: abrir o editor SQL
em [2]: abrir um script SQL
em [3]: indicar o script [schema-articles.sql] criado no parágrafo 5.4.6.

em [4]: o script foi carregado. Ele é executado.
em [5]: a tabela [ARTICLES] foi criada.
em [6, 7]: seu conteúdo

5.6.5. Driver JDBC de PostgreSQL

O driver JDBC do PostgreSQL está disponível na pasta [jdbc] da pasta de instalação do PostgreSQL:

Colocamos o arquivo Jdbc, assim como os anteriores (parágrafo 5.4.7), na pasta <jdbc>:

Para testar este driver JDBC, utilizaremos o Eclipse e o plug-in SQL Explorer. Recomenda-se ao leitor que siga os passos explicados no parágrafo 5.4.7. Apresentamos algumas capturas de tela relevantes:

no [1]: o arquivo do driver JDBC foi renomeado de PostgreSQL
em [2]: o driver JDBC, proveniente de PostgreSQL, está disponível

para [3]: definição da conexão (usuário, senha)=(jpa, jpa)
em [4]: a conexão está ativa
em [5]: banco de dados conectado
em [6]: o conteúdo da tabela [ARTICLES]

5.7. O SGBD a Oracle 10g Express

5.7.1. Instalação

O SGBD Oracle 10g Express está disponível no URL [http://www.oracle.com/technology/software/products/database/xe/index.html]:

em [1]: o site de download do Oracle 10g Express
em [2]: escolha uma versão para Windows. Após baixar o arquivo, execute-o:

em [1]: clique duas vezes no arquivo [OracleXE.exe]
em [2]: a primeira página do assistente de instalação

em [3]: aceitar a licença
em [4]: aceite os valores padrão.

em [5,6]: o usuário SYSTEM terá a senha “system”.
em [7]: inicia-se a instalação

A instalação do Oracle 10g Express cria uma pasta em [Démarrer / Programmes ]:

5.7.2. Iniciar/Encerrar o Oracle 10g

Assim como nos SGBD anteriores, o Oracle 10g foi instalado como um serviço do Windows com inicialização automática. Vamos alterar essa configuração:

[Démarrer / Panneau de configuration / Performances et maintenance / Outils d'administration / Services ]:

em [1]: clicamos duas vezes em [Services]
em [2]: vemos que existe um serviço chamado [OracleServiceXE], que está em execução ([3]) e que sua inicialização é automática ([4]).
em [5]: outro serviço da Oracle, chamado “Listener”, também está ativo e com inicialização automática.

Para alterar esse comportamento, clicamos duas vezes no serviço [OracleServiceXE]:

em [1]: configuramos o serviço para inicialização manual
em [2]: desativamos o serviço
em [3]: confirmamos a nova configuração do serviço

Proceder-se-á da mesma forma com o serviço [OracleXETNSListener] (ver [5] acima). Para iniciar e parar manualmente o serviço OracleServiceXE, é possível utilizar os atalhos da pasta [Oracle]:

em [1]: para iniciar o SGBD
em [2]: para encerrá-lo
em [3]: para administrá-lo (o que o inicia, caso ainda não esteja em execução)

5.7.3. Criação de um usuário jpa e de um banco de dados jpa

Na captura de tela acima, o aplicativo [3] permite administrar o SGBD Oracle 10g Express. Vamos iniciar o SGBD e o [1], e depois a aplicação de administração [3] por meio do menu acima:

no [1]: faça login como administrador do SGBD, aqui (system / system)
no [2]: crie um novo usuário

em [4]: nome de usuário
em [5, 6]: sua senha, neste caso jpa
em [7]: o usuário jpa foi criado

No Oracle, um usuário é automaticamente associado a um banco de dados com o mesmo nome. Portanto, o banco de dados jpa existe ao mesmo tempo que o usuário jpa.

5.7.4. Criação da tabela [ARTICLES] do banco de dados jpa

O OracleXE foi instalado com um cliente SQL que opera no modo de linha de comando. É possível trabalhar com mais conforto com o SQL Developer, também fornecido pel . Ele pode ser encontrado no site:

[http://www.oracle.com/technology/products/database/sql_developer/index.html]

em [1]: o site de download
em [2]: baixe uma versão para Windows sem o JRE caso ele já esteja instalado (como é o caso aqui), já que o [SQL Developer] é um aplicativo Java.

em [3]: descompactar o arquivo ZIP baixado
em [4]: execute o arquivo executável [sqldeveloper.exe]

em [5]: na primeira execução do [SQL Developer], especifique o caminho do JRE instalado no computador
em [5b]: criar uma nova conexão

em [6]: o SQL Developer permite conectar-se a diversos SGBD. Selecione Oracle.
em [7]: nome atribuído à conexão que está sendo criada
em [8]: proprietário da conexão
em [9]: sua senha (jpa)
em [10]: manter os valores padrão
em [11]: para testar a conexão (o Oracle deve estar em execução)
em [12]: para concluir a configuração da conexão
em [13]: os objetos do banco de dados jpa
em [14]: é possível criar tabelas. Assim como nos casos anteriores, vamos criar a tabela [ARTICLES] a partir do script criado no parágrafo 5.4.6.

em [15]: abre-se um script SQL
em [16]: indicamos o script SQL criado no parágrafo 5.4.6.
em [17]: o script que será executado

em [18]: o resultado da execução: a tabela [ARTICLES] foi criada. Clique duas vezes nela para acessar suas propriedades.
em [19]: o conteúdo da tabela.

5.7.5. Driver JDBC de OracleXE

O driver JDBC de OracleXE está disponível na pasta [jdbc/lib] da pasta de instalação de OracleXE [1]:

Colocamos o arquivo Jdbc [ojdbc14.jar], assim como os anteriores (parágrafo 5.4.7), na pasta <jdbc> [2]:

Para testar este driver JDBC, utilizaremos o Eclipse e o plug-in SQL Explorer. Recomenda-se ao leitor que siga os passos explicados no parágrafo 5.4.7. Apresentamos algumas capturas de tela relevantes:

no [1]: o arquivo do driver JDBC foi designado de OracleXE
em [2]: o driver JDBC, proveniente de OracleXE, está disponível

em [3]: definição da conexão (usuário, senha)=(jpa, jpa)
em [4]: a conexão está ativa
em [5]: banco de dados conectado
em [6]: o conteúdo da tabela [ARTICLES]

5.8. O SGBD e ao SQL Server Express 2005

5.8.1. Instalação

O SGBD SQL Server Express 2005 está disponível no URL [http://msdn.microsoft.com/vstudio/express/sql/download/]:

em [1]: primeiro baixe e instale a plataforma .NET 2.0
em [2]: em seguida, instale e baixe o SQL Server Express 2005
em [3]: em seguida, instale e baixe o SQL Server Management Studio Express, que permite administrar o SQL Server

A instalação do SQL Server Express cria uma pasta no [Démarrer / Programmes ]:

no [1]: o aplicativo de configuração do SQL Server. Também permite iniciar/parar o servidor
em [2]: o aplicativo de administração do servidor

5.8.2. Iniciar/Parar o servidor SQL

Assim como nos SGBD anteriores, o servidor SQL Express foi instalado como um serviço do Windows com inicialização automática. Vamos alterar essa configuração:

[Démarrer / Panneau de configuration / Performances et maintenance / Outils d'administration / Services ]:

para [1]: clicamos duas vezes em [Services]
em [2]: percebe-se que existe um serviço chamado [SQL Server], que está em execução ([3]) e que sua inicialização é automática ([4]).
em [5]: outro serviço relacionado ao SQL Server, chamado “SQL Server Browser”, também está ativo e com inicialização automática.

Para alterar esse comportamento, clicamos duas vezes no serviço [SQL Server]:

em [1]: definimos o serviço para inicialização manual
em [2]: desativamos o serviço
em [3]: confirmamos a nova configuração do serviço

Proceder-se-á da mesma forma com o serviço [SQL Server Browser] (ver [5] acima). Para iniciar e parar manualmente o serviço SQL, é possível utilizar o aplicativo [1] da pasta [SQL server]:

no [1]: certifique-se de que o protocolo TCP/IP esteja ativado (enabled) e, em seguida, acesse as propriedades do protocolo.
em [2]: na aba [IP Addresses], opção [IPAll]:
- o campo [TCP Dynamic ports] é deixado em branco
- a porta de escuta do servidor está definida como 1433 em [TCP Port]

em [3]: um clique com o botão direito do mouse no serviço [SQL Server] dá acesso às opções de iniciar/parar o servidor. Aqui, ele é iniciado.
em [4]: o servidor SQL está em execução

5.8.3. Criação de um usuário jpa e de um banco de dados jpa

Vamos iniciar o SGBD conforme indicado acima e, em seguida, o aplicativo de administração [1] por meio do menu abaixo:

no [1]: conectamo-nos ao servidor SQL como administrador do Windows
em [2]: configure as propriedades da conexão

em [3]: autoriza-se um modo misto de conexão ao servidor: seja com um login do Windows (um usuário do Windows), seja com um login do servidor SQL (conta definida no servidor SQL, independente de qualquer conta do Windows).
em [3b]: cria-se um usuário do servidor SQL

no [4]: opção [General]
em [5]: o login
em [6]: a senha (jpa aqui)
em [7]: opção [Server Roles]
em [8]: o usuário jpa terá permissão para criar bancos de dados

Confirmamos essa configuração:

em [9]: o usuário jpa foi criado
em [10]: estamos nos desconectando
em [11]: reconectamos

em [12]: conectando-se como usuário jpa/jpa
em [13]: uma vez conectado, o usuário jpa cria um banco de dados

em [14]: o banco de dados se chamará jpa
em [15]: e pertencerá ao usuário jpa
em [16]: o banco de dados jpa foi criado

5.8.4. Criação da tabela [ARTICLES] do banco de dados jpa

Assim como nos exemplos anteriores, vamos criar a tabela [ARTICLES] a partir do script criado no parágrafo 5.4.6.

em [1]: abrimos um script SQL
em [2]: indicamos o script SQL criado no parágrafo 5.4.6, página 240.
em [3]: é necessário fazer o login novamente (jpa/jpa)
em [4]: o script que será executado
em [5]: selecionar o banco de dados no qual o script será executado
em [6]: executá-lo

em [7]: o resultado da execução: a tabela [ARTICLES] foi criada.
em [8]: solicita-se a visualização do conteúdo
em [9]: o conteúdo da tabela.

5.8.5. Driver JDBC do SQL Server Express

em [1]: uma pesquisa no Google com o texto [Microsoft SQL Server 2005 JDBC Driver] nos leva à página de download do driver JDBC. Selecionamos a versão mais recente
em [2]: o arquivo baixado. Clicamos duas vezes nele. O arquivo é descompactado, criando uma pasta na qual encontramos o driver Jdbc [3]
em [4]: colocamos o arquivo Jdbc [sqljdbc.jar], assim como os anteriores (parágrafo 5.4.7), na pasta <jdbc>

Para testar este driver JDBC, utilizaremos o Eclipse e o plug-in SQL Explorer. Recomenda-se ao leitor que siga os passos explicados no parágrafo 5.4.7. Apresentamos algumas capturas de tela relevantes:

no [1]: foi especificado o arquivo do driver JDBC do servidor SQL
em [2]: o driver JDBC do servidor SQL está disponível

em [3]: definição da conexão (usuário, senha)=(jpa, jpa)
em [4]: a conexão está ativa
em [5]: banco de dados conectado
em [6]: o conteúdo da tabela [ARTICLES]

5.9. O SGBD e ao HSQLDB

5.9.1. Instalação

O SGBD HSQLDB está disponível no URL [http://sourceforge.net/projects/hsqldb]. Trata-se de um SGBD escrito em Java, que ocupa muito pouca memória e gerencia bancos de dados na memória, e não no disco. O resultado é uma velocidade de execução de consultas extremamente alta. Esse é seu principal diferencial. Os bancos de dados assim criados na memória podem ser recuperados quando o servidor é desligado e reiniciado. De fato, os comandos SQL emitidos para criar os bancos de dados são armazenados em um arquivo de logs para serem executados novamente na próxima inicialização do servidor. Assim, obtém-se a persistência dos bancos de dados ao longo do tempo.

O método tem suas limitações, e o HSQLDB não é um SGBD destinado a fins comerciais. Seu principal interesse reside em testes ou aplicativos de demonstração. Por exemplo, o fato de o HSQLDB ter sido escrito em Java permite incluí-lo em tarefas do Ant (Another Neat Tool), uma ferramenta Java para automação de tarefas. Assim, os testes diários de códigos em desenvolvimento, automatizados pelo Ant, poderão integrar testes de bancos de dados gerenciados pelo SGBD e pelo HSQLDB. O servidor será iniciado, desligado e gerenciado por tarefas Java.

em [1]: o site de download
em [2]: baixar a versão mais recente

em [3]: descompactar o arquivo zip baixado
em [4]: a pasta [hsqldb] resultante da descompactação
em [5]: a pasta [demo], que contém o script para iniciar o servidor [hsql] e [6], e em [7], o script para iniciar uma ferramenta simples de administração do servidor.

5.9.2. Iniciar/Parar o HSQLDB

Para iniciar o servidor HSQLDB, clique duas vezes no aplicativo [runManager.bat] [6] acima:

no [1]: vemos que, para encerrar o servidor, basta pressionar Ctrl-C na janela.

5.9.3. O banco de dados [test]

O banco de dados gerenciado por padrão está na pasta [data]:

em [1]: ao iniciar, o SGBD HSQL executa o script chamado [test.script]

CREATE SCHEMA PUBLIC AUTHORIZATION DBA
CREATE USER SA PASSWORD ""
GRANT DBA TO SA
SET WRITE_DELAY 10

linha 1: é criado um esquema [public]
linha 2: é criado um usuário [sa] com senha vazia
linha 3: o usuário [sa] recebe direitos de administração

No final, foi criado um usuário com direitos de administração. É esse usuário que utilizaremos a seguir.

5.9.4. Driver JDBC de HSQL

O driver JDBC de SGBD para HSQL está localizado na pasta [lib]:

em [1]: o arquivo [hsqldb.jar] contém o driver JDBC do SGBD HSQL
em [2]: colocamos esse arquivo, assim como os anteriores (parágrafo 5.4.7), na pasta <jdbc>

Para verificar esse driver JDBC, utilizaremos o Eclipse e o plug-in SQL Explorer. Recomenda-se ao leitor que siga os passos explicados no parágrafo 5.4.7. Apresentamos algumas capturas de tela relevantes:

no [1]: [window / preferences / SQL Explorer / JDBC Drivers]
em [2]: configura-se o servidor [HSQLDB]
em [3]: indica-se o arquivo [hsqldb.jar] que contém o driver JDBC
em [4]: o nome da classe Java do driver JDBC
em [5]: o driver JDBC está configurado

Feito isso, conectamo-nos ao servidor HSQL. É preciso iniciá-lo antes.

em [6]: cria-se uma nova conexão
em [7]: atribuímos um nome a ela
em [8]: queremos nos conectar ao servidor HSQLDB
em [9]: a URL do banco de dados ao qual queremos nos conectar. Será o banco de dados [test] visto anteriormente.
em [10]: conectamo-nos como usuário [sa]. Vimos que ele era administrador do SGBD.
em [11]: o usuário [sa] não possui senha.

Confirmamos a configuração da conexão.

no [12]: estamos nos conectando
em [13]: estamos nos identificando
em [14]: estamos conectados

em [15]: o esquema [PUBLIC] ainda não possui uma tabela
em [16]: vamos criar a tabela [ARTICLES] a partir do script [schema-articles.sql] criado no parágrafo 5.4.6.
em [17]: seleciona-se o script

em [18]: o script a ser executado
no [19]: ele é executado após a remoção de todos os comentários, pois o HSQLB não aceita.

após a execução do script, atualiza-se a exibição do banco de dados em [20]
em [21]: a tabela [ARTICLES] está presente
em [22]: seu conteúdo

Vamos parar e, em seguida, reiniciar o servidor HSQLDB. Feito isso, examinemos o arquivo [test.script]:

CREATE SCHEMA PUBLIC AUTHORIZATION DBA
CREATE MEMORY TABLE ARTICLES(ID INTEGER NOT NULL,NOM VARCHAR(20) NOT NULL,PRIX DOUBLE NOT NULL,STOCKACTUEL INTEGER NOT NULL,STOCKMINIMUM INTEGER NOT NULL,CONSTRAINT PK_ARTICLES PRIMARY KEY(ID),CONSTRAINT CHK_ID CHECK(ARTICLES.ID>0),CONSTRAINT CHK_PRIX CHECK(ARTICLES.PRIX>0),CONSTRAINT CHK_STOCKACTUEL CHECK(ARTICLES.STOCKACTUEL>0),CONSTRAINT CHK_STOCKMINIMUM CHECK(ARTICLES.STOCKMINIMUM>0),CONSTRAINT CHK_NOM CHECK(ARTICLES.NOM!=''),CONSTRAINT UNQ_NOM UNIQUE(NOM))
CREATE USER SA PASSWORD ""
GRANT DBA TO SA
SET WRITE_DELAY 10
SET SCHEMA PUBLIC
INSERT INTO ARTICLES VALUES(1,'article1',100.0E0,10,1)
INSERT INTO ARTICLES VALUES(2,'article2',200.0E0,20,2)
INSERT INTO ARTICLES VALUES(3,'article3',300.0E0,30,3)

Vemos que o SGBD armazenou os diversos comandos SQL executados na sessão anterior e que os reexecuta ao iniciar a nova sessão. Além disso, observa-se (linha 2) que a tabela [ARTICLES] é criada na memória (MEMORY). A cada sessão, os comandos SQL emitidos são armazenados em [test.log] para serem copiados no início da sessão seguinte para [test.script] e executados novamente no início da sessão.

5.10. O SGBD e do Apache Derby

5.10.1. Instalação

O SGBD Apache Derby está disponível no URL [http://db.apache.org/derby/]. Trata-se de um SGBD também escrito em Java e igualmente muito leve em termos de memória. Ele apresenta vantagens semelhantes às do HSQLDB. Ele também pode ser incorporado em aplicativos Java, c.a.d, tornando-se parte integrante do aplicativo e operando na mesma JVM.

em [1]: o site de download
em [2,3]: baixe a versão mais recente

em [3]: descompactar o arquivo zip baixado
em [4]: a pasta [db-derby-*-bin] resultante da descompactação
em [5]: a pasta [bin], que contém o script para iniciar o servidor [db derby] e [6], e em [7], o script para desligá-lo.

5.10.2. Iniciar/Parar o Apache Derby (Db Derby)

Para iniciar o servidor Db Derby, clique duas vezes no aplicativo [startNetworkServer] [6] acima:

em [1]: o servidor está iniciado. Ele será desligado com o aplicativo [stopNetworkServer] [7] acima.

5.10.3. Driver JDBC do Db Derby

O driver JDBC do SGBD Db Derby está localizado na pasta [lib] da pasta de instalação:

em [1]: o arquivo [derbyclient.jar] contém o driver JDBC do SGBD Db Derby
em [2]: colocamos esse arquivo, assim como os anteriores (parágrafo 5.4.7), na pasta <jdbc>

Para testar esse driver JDBC, utilizaremos o Eclipse e o plug-in SQL Explorer. Recomenda-se ao leitor que siga os passos explicados no parágrafo 5.4.7. Apresentamos algumas capturas de tela relevantes:

em [1]: [window / preferences / SQL Explorer / JDBC Drivers]
em [2]: o driver JDBC do Apache Derby não consta da lista. Nós o adicionamos.

em [3]: atribui-se um nome ao novo driver
em [4]: especifica-se o formato das URLs gerenciadas pelo driver JDBC
em [5]: indicamos o arquivo .jar do driver JDBC
em [5b]: o nome da classe Java do driver JDBC
em [5c]: o driver JDBC está configurado

Feito isso, conectamo-nos ao servidor Apache Derby. É preciso iniciá-lo antes.

em [6]: cria-se uma nova conexão
em [7]: atribuímos um nome a ela
em [8]: queremos nos conectar ao servidor Apache Derby
em [9]: a URL do banco de dados ao qual se deseja se conectar. Após o início padrão [jdbc:derby://localhost:1527], deve-se inserir o caminho de uma pasta no disco que contenha um banco de dados Derby. A opção [create=true] permite criar essa pasta caso ela ainda não exista.
em [10,11]: conectamo-nos como usuário [jpa/jpa]. Não aprofundei a questão, mas parece que é possível inserir o que quisermos como login e senha. Aqui, declaramos o proprietário do banco de dados, se create=true.

Valida-se a configuração da conexão.

em [12]: fazemos o login
em [13]: fazemos a identificação (jpa/jpa)
em [14]: estamos conectados

em [15]: o esquema [jpa] ainda não aparece.
em [16]: vamos criar a tabela [ARTICLES] a partir do script [schema-articles.sql] criado no parágrafo 5.4.6.
em [17]: seleciona-se o script

em [18]: o script a ser executado
em [19]: execute-o após remover todos os comentários, pois o Apache Derby, assim como o HSQLB, não os aceita.

após a execução do script, atualiza-se em [20] a exibição do banco de dados
em [21]: o esquema [jpa] e a tabela [ARTICLES] estão presentes
em [22]: o conteúdo da tabela [ARTICLES]

em [23]: o conteúdo da pasta [derby\jpa] na qual o banco de dados foi criado.

5.11. O framework Spring 2 do

O framework Spring 2 está disponível no endereço [http://www.springframework.org/download]:

em [1]: baixe a versão mais recente
No [2]: baixamos a versão chamada “com dependências”, pois ela contém os arquivos .jar das ferramentas de terceiros que o Spring integra e das quais precisamos o tempo todo.

em [3]: descompactamos o arquivo baixado
em [4]: a pasta de instalação do Spring 2.1

em [5]: na pasta <dist>, encontram-se os arquivos do Spring. O arquivo [spring.jar] reúne todas as classes do framework Spring. Elas também estão disponíveis por módulos na pasta <modules> em [6]. Se soubermos quais módulos são necessários, podemos encontrá-los aqui. Assim, evitamos incluir na aplicação arquivos dos quais ela não precisa.

em [7]: a pasta <lib> contém os arquivos das ferramentas de terceiros utilizadas pelo Spring
em [8]: alguns arquivos do projeto [jakarta-commons]

Quando o tutorial utiliza arquivos do Spring, é preciso buscá-los na pasta <dist> ou na pasta <lib> da pasta de instalação do Spring.

5.12. O contêiner EJB3 de JBoss

O contêiner EJB3 de JBoss está disponível no URL [http://labs.jboss.com/jbossejb3/downloads/embeddableEJB3]:

em [1]: baixamos JBoss e EJB3. É possível observar a data do produto (setembro de 2006), embora o download tenha sido feito em maio de 2007. É possível questionar se esse produto ainda está em desenvolvimento.
em [2]: o arquivo baixado

em [3]: o arquivo zip descompactado
em [4]: os arquivos [hibernate-all.jar, jboss-ejb3-all.jar, thirdparty-all.jar] formam o contêiner EJB3 de JBoss. É necessário colocá-los no classpath do aplicativo que utiliza esse contêiner.

5. Anexos

5.1. Java

5.2. Eclipse

5.2.1. Instalação básica

5.2.2. Escolha do compilador

5.2.3. Instalação dos plug-ins do Callisto do

5.2.4. Instalação do plug-in [TestNG]

5.2.5. Instalação do plug-in [Hibernate Tools]

5.2.6. Instalação do plug-in [SQL Explorer]

5.3. O contêiner de servlets Tomcat 5.5

5.3.1. Instalação

5.3.2. Implantação de uma aplicação web no servidor Tomcat

5.3.3. Implantação

5.3.4. Administração do Tomca

5.3.5. Gerenciamento de aplicativos web implantados

5.3.6. Aplicativo web com página inicial

5.3.7. Integração do Tomcat no Eclipse

5.4. O SGBD a o Firebird

5.4.1. SGBD Firebird

5.4.2. Trabalhando com o SGBD Firebird com o IB- Expert

5.4.3. Criação de uma tabela de dados

5.4.4. Inserção de dados em uma tabela

5.4.5. O editor SQL de [IB-Expert]

5.4.6. Exportação de um banco de dados Firebird para um script SQL

5.4.7. Driver JDBC do Firebird para o ** **

5.5. O SGBD e o MySQL5

5.5.1. Instalação

5.5.2. Iniciar/Parar o MySQL5

5.5.3. Clientes de administração do MySQL

5.5.4. Criação de um usuário jpa e de um banco de dados jpa

5.5.5. Driver JDBC de MySQL5

5.6. O SGBD o PostgreSQL

5.6.1. Instalação

5.6.2. Iniciar/Encerrar o PostgreSQL

5.6.3. Gerenciar o PostgreSQL

5.6.4. Criação de um usuário jpa e de um banco de dados jpa

5.6.5. Driver JDBC de PostgreSQL

5.7. O SGBD a Oracle 10g Express

5.7.1. Instalação

5.7.2. Iniciar/Encerrar o Oracle 10g

5.7.3. Criação de um usuário jpa e de um banco de dados jpa

5.7.4. Criação da tabela [ARTICLES] do banco de dados jpa

5.7.5. Driver JDBC de OracleXE

5.8. O SGBD e ao SQL Server Express 2005

5.8.1. Instalação

5.8.2. Iniciar/Parar o servidor SQL

5.8.3. Criação de um usuário jpa e de um banco de dados jpa

5.8.4. Criação da tabela [ARTICLES] do banco de dados jpa

5.8.5. Driver JDBC do SQL Server Express

5.9. O SGBD e ao HSQLDB

5.9.1. Instalação

5.9.2. Iniciar/Parar o HSQLDB

5.9.3. O banco de dados [test]

5.9.4. Driver JDBC de HSQL

5.10. O SGBD e do Apache Derby

5.10.1. Instalação

5.10.2. Iniciar/Parar o Apache Derby (Db Derby)

5.10.3. Driver JDBC do Db Derby

5.11. O framework Spring 2 do

5.12. O contêiner EJB3 de JBoss

5.4.7. Driver JDBC do Firebird para o ` `