COLÉGIO ESTADUAL ULYSSES GUIMARÃES

CURSO TÉCNICO PROFISSIONALIZANTE EM INFORMÁTICA

ERINALDO SANCHES NASCIMENTO

JAVA ENTERPRISE EDITION:

PERSISTÊNCIA DE BANCO DE DADOS

FOZ DO IGUAÇU

2013

SUMÁRIO

1. PERSISTÊNCIA DE BANCO DE DADOS ............................................................. 1

1.1 ENTENDENDO JAVA EE ............................................................................................ 1

1.1.1 Padrões .............................................................................................................. 2

1.1.2 Arquitetura .......................................................................................................... 2

1.1.3 Componentes ..................................................................................................... 2

1.1.4 Containers .......................................................................................................... 3

1.1.5 Serviços .............................................................................................................. 4

1.2 CONFIGURANDO UMA FONTE DE DADOS ...................................................................... 4

1.3 SERVIDOR DE APLICAÇÃO JAVA EE: GLASSFISH .......................................................... 6

1.3.1 Baixar e Instalar o GlassFish .............................................................................. 6

1.3.2 Configurar o GlassFish no IDE Eclipse .............................................................. 9

1.3.3 Testar o Servidor GlassFish ............................................................................. 15

1.4 CRIAR UM PROJETO EJB ........................................................................................ 16

1.5 ADICIONAR ASPECTOS JPA ...................................................................................... 18

1.6 REFERÊNCIA BIBLIOGRÁFICA ................................................................................... 21

1

1. PERSISTÊNCIA DE BANCO DE DADOS

As empresas hoje vivem em um mundo global competitivo. Elas precisam de

aplicações que satisfaçam suas necessidades de negócios, que estão ficando mais

e mais complexa. As empresas estão distribuídas por continentes, fazem negócio

através da Internet, em diferentes países e os seus sistemas têm de ser

internacionalizado e pronto para lidar com diferentes moedas e fusos horários. Tudo

isso ao mesmo tempo reduzir custos, reduzir os tempos de resposta dos seus

serviços, o armazenamento de dados de negócios em armazenamento confiável e

seguro, oferecendo várias interfaces gráficas para seus clientes, funcionários e

fornecedores.

A maioria das empresas tem que combinar esses desafios inovadores com

seus sistemas de informação (SI) existentes, enquanto ao mesmo tempo o

desenvolvimento de aplicativos de negócios para se comunicar com os parceiros.

Também não é raro para uma empresa ter que coordenar dados armazenados em

diferentes locais, transformados por várias linguagens de programação, e

encaminhado através de protocolos diferentes. E, claro, tem que fazer isso sem

perder dinheiro, o que significa evitar falhas no sistema e estar altamente disponível,

escalonável e seguro.

1.1 ENTENDENDO JAVA EE

As aplicações empresariais têm de enfrentar a mudança e complexidade, e

ser robusto. É exatamente por isso Java Enterprise Edition (Java EE) foi criado.

Se o desenvolvedor precisa de uma aplicação transacional, segura,

interoperável e distribuída, usa o Enterprise Edition do Java. O Java EE fornece um

modo padrão de lidar com transações com o Java Transaction API (JTA),

mensagens com o Java Message Service (JMS), ou persistência com Java

Persistence API (JPA ). O Java EE é um conjunto de especificações destinadas para

aplicações empresariais, visto como uma extensão do Java SE, facilita o

2

desenvolvimento de aplicações distribuídas, é robusto, potente e altamente

disponível.

1.1.1 Padrões

O Java EE é baseado em padrões. O Java EE fornece padrões que são

implementados por várias fontes comerciais (WebLogic, Websphere, MQSeries, etc)

ou frameworks open source (GlassFish, JBoss, Hibernate, Open JPA, Jersey, etc)

para manipulação de transações, segurança, persistência de objeto, e assim por

diante.

1.1.2 Arquitetura

Java EE é um conjunto de especificações implementadas por diferentes

containers. Containers são ambientes de tempo de execução Java EE que fornecem

determinados serviços para os componentes que abrigam, tais como gestão do ciclo

de vida, de injeção de dependência, e assim por diante. Estes componentes usam

contratos bem definidos para comunicar-se com a infraestrutura do Java EE e outros

componentes. Eles precisam ser empacotados em uma forma padrão antes de ser

implantado.

1.1.3 Componentes

O ambiente de execução Java EE define quatro tipos de componentes que

uma aplicação deve suportar:

Applets: aplicações GUI executadas em um navegador da web. Usam a API

Swing para fornecer poderosas interfaces de usuário.

3

Aplicativos: programas executados em um cliente. São tipicamente GUIs ou

programas de processamento em lote que têm acesso a todas as facilidades da

camada intermediária do Java EE.

Aplicações web (feito de servlets, filtros servlet, listeners de eventos web,

páginas JSP, e JSF): executadas em um container web e responder às

solicitações HTTP de clientes web.

Aplicações empresariais (feitas de Enterprise Java Beans, Java Message

Service, Java Transaction API, etc.): executadas em um container EJB. EJBs são

componentes gerenciados por container para processamento de lógica de

negócios transacional. Eles podem ser acessados localmente e remotamente.

1.1.4 Containers

A infraestrutura Java EE é dividida em domínios lógicos chamados

containers. Cada container tem uma função específica, suporta um conjunto de

APIs, e oferece serviços aos componentes (segurança, acesso de banco de dados,

manipulação de transações, nomeando diretório, injeção de recursos). Containers de

ocultam a complexidade técnica e aumentam a portabilidade.

O container da aplicação cliente (ACC) inclui um conjunto de classes Java,

bibliotecas e outros arquivos necessários para trazer injeção, gerenciamento,

segurança e nomear serviço para aplicativos Java SE (Swing, processamento em

lote, ou apenas uma classe com um método main()). O ACC comunica-se com o

container EJB usando RMI-IIOP e o container Web com HTTP.

O container Web é usado para alimentar páginas web para navegadores

cliente. O container EJB é responsável por gerenciar a execução enterprise beans

contendo a camada lógica de negócios da aplicação Java EE.

4

1.1.5 Serviços

Containers fornecem serviços básicos aos componentes implantados.

Assim, o desenvolvedor pode se concentrar na implementação da lógica de negócio

ao invés de resolver os problemas técnicos enfrentados em aplicações empresariais.

O Java EE oferece os seguintes serviços:

Java Transaction API (JTA): oferece uma API de demarcação de transação

usada pelo container e aplicação. Também fornece uma interface entre o

gerenciador de transações e um gerenciador de recursos no nível do Service

Provider Interface (SPI).

Java Persistence API (JPA): API padrão para mapeamento objeto-relacional

(ORM). Com a Java Persistence Query Language (JPQL), é possível consultar os

objetos armazenados no banco de dados.

Muitos outros serviços são implementados no Java EE.

1.2 CONFIGURANDO UMA FONTE DE DADOS

Precisamos criar uma fonte de dados para que quando implantar e executar

o aplicativo no servidor, o aplicativo tem acesso ao banco de dados.

1. Inicie o MySQL Workbench.

5

2. Na parte central da janela escolha Create New EER Model. Crie o diagrama

conforme apresentado na figura abaixo.

3. Feito isso, clique em File, Export, Forward Engineer SQL Create Script.

4. Abrirá uma caixa de diálogo, dê o nome Escola para o script. Clique em Next.

5. Selecione a primeira opção, Export MySQL Table Objects. Clique em Next.

6. Na última tela clique em Finish para concluir.

7. Volte a janela principal do MySQLWorkbench, e crie uma nova conexão,

chamada Escola, clicando em New Connection.

6

8. Clique em Open Connection to Start Querying, ou escolha Escola na lista abaixo.

9. Clique em File, Open SQL Script, e selecione o arquivo Escola.sql.

10. Clique no botão Execute SQL Script.

1.3 SERVIDOR DE APLICAÇÃO JAVA EE: GLASSFISH

GlassFish é um servidor de aplicação Java EE compatível, open source,

pronto para produção.

GlassFish fornece a aplicação de recursos completos do Java EE. A

plataforma Java EE apresenta o perfil da Web para aplicações centradas na Web, e

inclui tecnologias, tais como tais como JAX-RS 1.1, JavaServer Faces (JSF) 2.0,

Enterprise JavaBeans (EJB) 3.1 , Java Persistence (JPA) 2.0, Context and

Dependency Injection (CDI) 1.0 e muito mais.

1.3.1 Baixar e Instalar o GlassFish

Baixe a última versão estável do servidor de aplicação GlassFish.

Inicie o arquivo executável para a instalação.

Clique em próximo.

7

Mantenha a opção de instalação típica selecionada e clique no botão

Próximo.

Não precisa alterar o diretório de instalação do GlassFish. Clique no botão

Próximo para avançar.

8

Ative a ferramenta de atualização, para que ele colete as atualizações

periódicas. Clique no botão Próximo para avançar. Na próxima tela clique no botão

Instalar.

Forneça o nome do usuário e a senha. Dê um nome para o serviço. Clique

em Próximo para avançar na configuração.

Se a configuração ocorreu sem nenhum erro, uma tela com o resultado da

configuração deve ser exibida.

9

Clique no botão Próximo para avançar. O resumo deve ser apresentado.

Clique no botão Sair.

A janela do navegador aparecerá para que seja feito o registro da instalação

do GlassFish. Caso tenha uma conta, registre-se.

1.3.2 Configurar o GlassFish no IDE Eclipse

Antes de configurar é necessário certificar-se que o JDK, o glassfish e o IDE

Eclipse estejam instalados na máquina.

1. Abra o Eclipse e pressione as teclas Ctrl+3 e uma janela surgirá, digite Servers e

clique na primeira opção como na imagem abaixo. A aba Servers surgirá.

10

2. Clique com botão direito e selecione New, Server.

3. Por padrão, o eclipse não possui os adaptadores necessários para interagir com

o glassfish. Então, para adicioná-los clique no link Download addtional server

adapter. Clique na versão Oracle GlassFish Server Tolls e depois no botão Next.

Para fazer o download é necessário aceitar o acordo de licença. Clique em

Finish.

11

4. Depois da instalação o Eclipse precisa ser reiniciado, clique em Restart Now.

5. Abra normalmente o Eclipse. Na aba Servers clique com o botão direito do

mouse e selecione New, Server. Agora, a pasta com os adaptadores do glassfish

aparecerá. Clique em GlassFish 3.1 e depois em Next.

12

6. O glassfish utiliza algumas ferramentas contidas no JDK. Portanto, é necessário

verificar se o Eclipse está indicando a utilização de um JDK. Caso esteja

utilizando um JRE, altere essa configuração seguindo os passos abaixo. Clique

em Installed JRE preferences.

7. Clique em Add…, selecione Standard VM e clique em Next.

13

8. Escolha o diretório clicando em Directory. Selecione a pasta onde está instalado

o JDK. Confira os dados e clique em Finish.

9. Escolha o JDK que acabamos de configurar. Indique o diretório onde o glassfish

foi descompactado. Clique em Browse… Procure a pasta “glassfish3/glassfish”

clique em OK. Clique em Next.

14

10. Nesta tela podemos escolher uma senha para o glassfish, mas isso não é

necessário. Clique em Next.

11. Nessa tela é possível escolher quais projetos serão implantados no glassfish. Se

nenhum projeto que possa ser implantado no glassfish existir, clique em Finish.

15

1.3.3 Testar o Servidor GlassFish

O servidor está aparecendo na aba Servers.

Para testá-lo clique com o botão direito e depois em Start.

O glassfish foi inicializado.

Acesse a url: localhost:8080 para verificar se o glassfish foi inicializado.

16

1.4 CRIAR UM PROJETO EJB

No Eclipse, crie um projeto EJB. Especifique um nome de projeto e clique

em New Runtime para configurar um tempo de execução alvo para o GlassFish 3.1

caso não esteja configurado, como mostra a imagem abaixo:

17

Selecione a configuração padrão para o GlassFish 3.1, e clique em Next,

para avançar para a tela seguinte:

Selecione a configuração padrão do módulo EJB e clique em Finish. Um

projeto EJB será criado.

Clique com o botão direito do mouse no nó do projeto na aba Project

Explorer e selecione Propriedades. Selecione Project Facets.

18

Um projeto EJB e beans de entidade requer aspectos de projeto JPA para

persistência de banco de dados. Criamos um projeto EJB, mas este não tem

aspectos de projeto JPA ativado por padrão. Clique no botão OK para concluir.

1.5 ADICIONAR ASPECTOS JPA

Para configurar uma fonte de dados, abra a janela Data Source Explorer.

Clique com o botão direito do mouse sobre Database Connections e selecione New.

19

Na caixa de diálogo que surgir selecione MySQL, e dê o nome da conexão

de Escola. Clique no botão Next para avançar ao próximo passo.

Especifique o nome do esquema que contém a fonte de dados.

20

Clique em Test Connection para confirmar o ping. Clique em Next para ver o

resumo e depois em Finish.

Para criar beans de entidade requer aspectos de projeto JPA. Para adicionar

aspectos do projeto JPA, clique no botão + ao lado de JPA Content, depois dê um

duplo clique sobre persistence.xml. Clique na aba Connection e configure a fonte de

dados conforme a tela a seguir:

Na caixa Transaction type selecione Resource Local. Depois clique no link

Populate from connection... Abrirá uma caixa de diálogo, nela escolha a conexão

Escola.

Clique na abra Source para ver o arquivo persistence.xml do projeto

EJB3JPA.

21

1.6 REFERÊNCIA BIBLIOGRÁFICA

BAI, Ying. Practical database programming with Java. Hoboken, NJ: John Wiley &

Sons, Inc., 2011.

VOHRA, Deepak. Java EE Developmente with Eclipse. Birmingham, UK: Packt

Publishing Ltd., 2012

GONCALVES, Antonio. Beginning Java EE 6 Platform with GlassFish 3, 2nd Ed.

New York, NY: Apress, 2010