EJB – Enterprise JavaBeans com Glassfish e NetBeans

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (6)  (0)

Veja neste artigo as definições e exemplos de aplicações corporativas utilizando o EJB no Glassfish unidos a IDE Netbeans. Por meio deste, são apresentados exemplos de código para melhor compreensão dessa tecnologia.


Neste artigo apresento a Edvania Votri, que pode ser contatada pelo e-mail edvotri@gmail.com. A Edvania foi minha aluna em algumas disciplinas de sua graduação e está concluindo o último período do curso de Tecnologia em Análise e Desenvolvimento de Sistemas da UTFPR câmpus Medianeira, neste primeiro semestre de 2012.

1. Introdução

Sistemas corporativos são comumente usados por empresas de pequeno e grande porte e incluem vários processos ou tarefas que atendem a necessidade de cada empresa, por este fato podem também ser denominadas regras de negócio. Cada aplicação possui regras de negócio próprias já que elas são consequência imediata do contexto da aplicação.

A arquitetura Enterprise JavaBeans (EJB) permite que as regras de negócio sejam implementadas em componentes específicos denominados Session Beans. O EJB é executado dentro de um EJB Container, sendo este o responsável pela implementação dos recursos oferecidos às aplicações.

De acordo com Oracle (2012), “Enterprise JavaBeans (EJB) é uma arquitetura de componentes do lado do servidor para a plataforma Java Enterprise Edition (Java EE). A tecnologia EJB permite o desenvolvimento simplificado e rápido de aplicativos distribuídos, transacionais, seguros e portáteis baseados na tecnologia Java”.

Segundo CAELUM (2011) grande parte dos sistemas corporativos baseiam-se na arquitetura definida pelo padrão Enterprise JavaBeans (EJB), com isso suas aplicações são beneficiadas no tocante a alguns atributos tais como: transações, segurança, remotabilidade, multithreading e concorrência, persistência, gerenciamento de objetos e integração. Esta arquitetura também possui por definição um suporte integrado com o Java Transaction API (JTA) oferecendo possibilidade de realizar transações distribuídas.

Com relação à segurança, o EJB tem suporte a autenticação e autorização. Dessa maneira os desenvolvedores das aplicações não precisam implementar essa lógica, pelo fato desta fazer parte da arquitetura do mesmo, bem como o acesso remoto por meio de protocolos de comunicação o que permite que aplicações EJB possam ser expostas como Web Service. Outra vantagem dessa arquitetura é o acesso múltiplo aos sistemas corporativos, ou seja, vários usuários com acesso simultâneo, mas de maneira controlada evitando problemas de concorrência. (CAELUM, 2011)

São oferecidos aos objetos que formam uma aplicação EJB mecanismos de injeção de dependências, facilidades para utilizar os serviços dos provedores de persistência que seguem a especificação JPA e controle do ciclo de vida que garante acesso a uma quantidade variável de usuários. Por fim a arquitetura Enterprise JavaBeans é altamente integrada com os componentes da plataforma Java EE. (CAELUM, 2011)

2. Ferramentas

O Glassfish é um servidor de aplicações que usa a tecnologia Java Enterprise Edition (Java EE), baseado na plataforma Java para desenvolver serviços e aplicações web. É também uma ferramenta open-source que suporta todas as especificações da API Java EE, tais como JDBC, RMI, JMS, JMX e possui algumas especificações para componentes Java EE. (DOMINGUES, 2011)

O Netbeans é um Ambiente de Desenvolvimento Integrado (open-source) para desenvolvedores de software. Ele possui ferramentas necessárias para que sejam desenvolvidas aplicações profissionais, empresariais, web, aplicações móveis com a plataforma Java, C, C + +, PHP, JavaScript e Groovy. Também tem suporte completo para Java EE 6, permitindo o desenvolvimento de componentes incluindo páginas web, servlets, web services, Enterprise Java Beans (EJB 3.1), JSF, JPA, bem como a especificação JSR 299 cujo objetivo é unir os modelos dos componentes do JSF managed bean com o EJB para apoio a contextos e injeção de dependência. Por fim a IDE possui suporte para o JavaFx 2.0, ferramentas para depuração visual do swing e interfaces de usuário JavaFx., facilitando o desenvolvimento de aplicativos baseados em padrões web e corporativos, que podem ser acessados por clientes de várias maneiras, seja por meio de dispositivos móveis ou via internet (navegadores). (NETBEANS, 2012)

3. Aplicação Exemplo

O objetivo deste projeto é exemplificar uma aplicação utilizando EJB, que tem como função principal gerenciar as regras de negócio desta. Para isso será apresentado um exemplo para compra de livros (carrinho de compras on-line) onde será possível fazer a adição do livro ao carrinho, realizar a busca na lista de livros existentes, obter o valor total da compra e finalizar a compra do cliente apresentando seu valor. Será utilizado a IDE Netbeans versão 7.0.1 e a implementação utilizando o Glassfish versão 3.1 no EJB.

3.1. Preparando o Ambiente

Inicialmente faz-se necessário a instalação das ferramentas a serem utilizadas. Caso ainda não possua a IDE Netbeans é possível optar pela versão que possui o Glassfish embutido, sendo que este se encontra em: http://glassfish.java.net/public/downloadsindex.html#top, ou adicionar o servidor à ferramenta. O download do Netbeans sem o Glassfish encontra-se em: .

A instalação da versão do Netbeans que necessita da adição do servidor Glassfish é feita executando o arquivo install.exe, a seguir selecione sempre a opção “next (próximo)”, lembrando que desta maneira todas as configurações permanecerão como padrão definido pela IDE.

O servidor de aplicações Glassfish 3.1 pode ser encontrado em: e em seguida sua adição ao Netbeans procede-se da seguinte maneira: na aba serviçosservidor (clicar com o botão direito nesta opção e escolher: “add server”) será apresentada uma janela semelhante a da figura 1, a seguir escolher um servidor que neste caso é o GlassFish Server3.x e opção “next”.

Tela do Netbeans: Escolhendo o Servidor

Figura 1: Tela do Netbeans: Escolhendo o Servidor

Neste momento surgirá uma nova janela de acordo com a apresentada na figura 2, por meio da qual será adicionado o servidor. Nesta se tem a opção de procurar a versão deste no computador ou fazer download se necessário. Sendo assim deve-se escolher a opção “browser” e procurar o diretório onde o Glassfish foi instalado, por padrão este se encontra em “C:\”. Em seguida escolher novamente opção “next”.

Tela Netbeans: Adicionando o Servidor

Figura 2: Tela Netbeans: Adicionando o Servidor

Para finalizar esta etapa de adição do servidor ao Netbeans, basta somente dar nome ao domínio – finalizar com a opção “finish” conforme a figura 3 apresenta.

Tela Netbeans: Nome de domínio

Figura 3: Tela Netbeans: Nome de domínio

3.2. Estruturando o Projeto

A partir de agora se inicia a montagem dos projetos necessários para o funcionamento da aplicação, ou seja, serão desenvolvidas quatro aplicações para compor o projeto como um todo. As duas primeiras são aplicações Java Application, a terceira será uma aplicação Java EE (Java Enterprise Application) e a última será um módulo EJB anexado ao anterior no momento de sua criação.

3.2.1. Projeto BaseEJB1

O primeiro projeto será nomeado como BaseEJB1, este possuirá dois pacotes: br.edu.utfpr.modelo e br.edu.utfpr.ejb, nos quais serão criadas uma classe (Livro) e uma interface (ICarrinho) respectivamente, cuja finalidade é manter as classes e interfaces comuns, tanto para a aplicação servidora como cliente. Dessa maneira este projeto trata de uma parte da camada de modelo de negócio da aplicação. A estrutura ficará semelhante à figura 4.

Estrutura do Projeto BaseEJB1

Figura 4: Estrutura do Projeto BaseEJB1

A listagem 1 apresenta a interface de utilização ICarrinho. Como se pode notar é uma interface Java e esta contém somente a assinatura dos métodos que posteriormente serão implementados. Todos os métodos utilizados no projeto devem ter sua assinatura descrita nessa interface, cujo objetivo é definir as ações , ou seja, chamadas aos métodos que deverão ser implementadas pela aplicação.

Listagem 1: Interface ICarrinho

package br.edu.utfpr.ejb;
import br.edu.utfpr.modelo.Livro;
import java.util.List;
public interface ICarrinho {
	void addLivro(Livro livro);
	List getLivros();
	double getTotal();
	void finalizaCompra();
}

A listagem 2 apresenta a classe “Livro”, uma classe Java simples que implementa serializable por questões de persistência, ou seja, é utilizada quando existe a necessidade de gravar e recuperar dados em disco ou caso seja necessário enviar esses dados por meio da rede, já que a serialização de objetos cria um stream de bytes. Também são apresentados nessa listagem os métodos padrões get/set.

Listagem 2: Classe Livro

package br.edu.utfpr.modelo;

import java.io.Serializable;
public class Livro implements Serializable {
	private static final long serialVersionUID = 1L;
	private String nome;
	private double preco;

	public double getPreco() {}

	public void setPreco(double preco) {}

	public String getNome() {}

	public void setNome(String nome) {}
}

3.2.2. Projeto Cliente

O projeto Cliente é composto por dois pacotes, sendo que estes são compostos por um arquivo simples, jndi.properties (default package) e uma classe cujo nome é Cliente (br.edu.utfpr.md.cliente) e esta será a classe executável. Também a este projeto o cliente são acrescentados os jars correspondentes do lado cliente: app-servrt.jar, gf-client.jar e javaee.jar, para isso pode ser criada uma nova biblioteca (clicar com botão direito sobre libraries e escolher a opção “add librarie”), a seguir adicionar os jars a esta biblioteca criada ou simplesmente adicionar os jars diretamente ao projeto (clicar com o botão direito do mouse sobre a pasta “libraries”). A figura 5 apresenta a estrutura deste projeto, nota-se que o projeto BaseEJB1 foi anexado como biblioteca (para tal deve-se selecionar o ícone “libraries”, clicar com o botão direito do mouse sobre o mesmo e selecionar a opção “add project”. A seguir selecionar o projetoBaseEJB1 para ser adicionado). É necessário que se faça a adição do projeto BaseEJB1, pois é nele que estão a classe e a interface utilizadas pelo cliente.

Estrutura do Projeto Cliente

Figura 5: Estrutura do Projeto Cliente

A listagem 3 apresenta o conteúdo do arquivo jndi.properties que serve para localizar o servidor glassfish na aplicação, ou seja, ele será usado pelo contexto da aplicação na classe cliente.

Listagem 3: Arquivo jndi.properties

java.naming.factory.initial=com.sun.enterprise.naming.SerialInitContextFactory
java.naming.factory.url.pkgs=com.sun.enterprise.naming
java.naming.factory.state=com.sun.corba.ee.impl.presentation.rmi.JNDIStateFactoryImpl
org.omg.CORBA.ORBInitialHost=localhost
org.omg.CORBA.ORBInitialPort=3700

A listagem 4 representa a aplicação do lado Cliente cuja função é executar a criação do objeto do tipo livro (classe Livro) e atribuir valores ao mesmo. Também nesta classe ocorrem às chamadas aos métodos implementados pela classe responsável (CarrinhoBean).

Listagem 4: Classe Cliente (main)

package br.edu.utfpr.md.cliente;

import br.edu.utfpr.ejb.ICarrinho;
import br.edu.utfpr.modelo.Livro;
import java.rmi.RemoteException;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class Cliente {

    	public static void main(String[] args) throws NamingException, RemoteException {
		InitialContext ic = new InitialContext();
		
		ICarrinho carrinho = (ICarrinho) ic.lookup("java:global/EAR1/EAR1-ejb/CarrinhoBean");
		
		Livro livro = new Livro();
		livro.setNome("OO com Java");
		livro.setPreco(30.0);
		
		carrinho.addLivro(livro);
    	            System.out.println(carrinho.getTotal());
		carrinho.finalizaCompra();
		carrinho.addLivro(livro);
	}
}

3.2.3. Projeto EAR1

E finalmente os dois últimos projetos que serão adicionados ao projeto EAR1 totalizando a aplicação em sua totalidade, estes se caracterizam como aplicações Java EE.

O primeiro passo deste tópico deve ser criar um novo projeto Java EE, escolher a opção Java EnterpriseApplication, e a seguir opção “next”, conforme a figura 7 demonstra.

Tela Criando um Projeto Enterprise Application

Figura 6: Tela Criando um Projeto Enterprise Application

A seguir será apresentada a tela para nomear o projeto e o caminho onde o mesmo será salvo, conforme demonstra a figura 8. Escolher opção “next”.

Tela: Nome e Caminho do Projeto

Figura 7: Tela: Nome e Caminho do Projeto

Na tela seguinte é necessário assinalar a opção “Create EJB Module” (figura 9), esta opção permitirá criar o último projeto de maneira automática (EAR1-ejb), este último projeto será a aplicação servidora onde está contida a classe CarrinhoBean, responsável pela implementação dos métodos assinados na interface ICarrinho, assim cada vez que a aplicação cliente for executada, os métodos da classe CarrinhoBean serão invocados. A seguir opção “finish” e os projetos que fazem parte deste serão criados, num total de dois. Conforme a estrutura da figura 6 o projeto EAR1-ejb é embutido no projeto EAR1.

Criando o Módulo EJB

Figura 8: Criando o Módulo EJB

Nestes últimos projetos é importante conferir se a classe CarrinhoBean (localizada no pacote: br.edu.utfpr.md) e a BaseEJB1(que contém a interface e a classe Cliente) compõem este projeto. Ambos são necessários para a totalidade da aplicação. A estrutura dos projetos EAR1 e EAR1-ejb ficarão semelhantes à representada pela figura 9.

Estrutura do Projeto EAR1

Figura 9: Estrutura do Projeto EAR1

O próximo passo é fazer a classe CarrinhoBean que terá a responsabilidade de implementar os métodos descritos na interface, sendo esta uma classe de suma importância.

Listagem 5: Classe CarrinhoBean

package br.edu.utfpr.md.ejb;

import br.edu.utfpr.ejb.ICarrinho;
import br.edu.utfpr.modelo.Livro;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.List;
import javax.ejb.Remote;
import javax.ejb.Stateful;
@Stateful
@Remote(ICarrinho.class)
public class CarrinhoBean implements ICarrinho {
	private static final long serialVersionUID = 1L;
	private double total;
	private List livros = new ArrayList();
	public CarrinhoBean() throws RemoteException {
		super();
	}
	@Override
	public void addLivro(Livro livro) {
		livros.add(livro);
		total += livro.getPreco();
		System.out.printf("Livro " + livro.getNome()
				+ " adicionado com sucesso.");
	}

	@Override
	public List getLivros() {
		System.out.println("Carrinho devolvendo a lista de livros.");
		return this.livros;
	}

	@Override
	public double getTotal() {
		System.out.println("Carrinho devolvendo o total " + total);
		return this.total;
	}

	@Override
	public void finalizaCompra() {
		System.out.println("Finalizando a compra de " + getLivros().size());
		for (Livro livro : getLivros()) {
			System.out.println(livro.getPreco() + "-" + livro.getNome());
		}
	}
}

Na classe CarrinhoBean apresentada por meio da tabela 5, além de ter a implementação dos métodos descritos na interface ICarrinho, percebe-se também dois tipos de anotações: @Stateful e @Remote.

A primeira anotação - @Stateful - é feita para que o estado do objeto (carrinho) seja mantido, desta maneira mantendo os produtos no caso os livros dentro de um mesmo conjunto ou carrinho.

A segunda anotação - @Remote – é definida pelo fato de poder ser acessada remotamente, ou seja, tanto por aplicações que estejam no mesmo servidor de aplicação quanto aplicações que não estejam.

3.3. Resultados

Se todas as etapas do tópico anterior foram cumpridas de maneira correta, na console referente à aba do GlassFish Server (figura 10) será apresentada uma mensagem conforme a figura 11. Isso significa que o servidor foi iniciado de maneira correta. Caso não apareça o resultado na console do Netbeans, selecionar o menu “window” da IDE e escolher o submenu “output (saída)” para que o resultado da execução da aplicação seja exibido na console.

Console do Netbeans (abas)

Figura 10: Console do Netbeans (abas)

Resultado da Aba GlassFish Server

Figura 11: Resultado da Aba GlassFish Server

Para conferência na aba do projeto EAR1 aparecerá a mensagem que a aplicação foi executada com sucesso conforme a figura 12. Este resultado significa que a aplicação foi executada com sucesso e apresenta também o tempo de execução.

Mensagem de Sucesso na Execução do Projeto EAR1

Figura 12: Mensagem de Sucesso na Execução do Projeto EAR1

Se o servidor está executando de maneira correta e no projeto também não ocorreram erros, é necessário estar atento ao caminho descrito na figura 13. Este caminho (EAR1 se refere ao projeto Java Enterprise, o EAR1-ejb é o módulo criado juntamente com o projeto citado anteriormente. CarrinhoBean é a classe que implementa os métodos a serem invocados no instante da utilização do carrinho – compra do livro) e faz a ligação entre a aplicação Cliente e o Projeto EAR1 (lado -servidor). O ponto final deste caminho é a classe CarrinhoBean – que possui a implementação dos métodos descritos na interface, ou seja, é a chamada aos métodos desta classe.

Caminho Usado pela Classe Cliente (ic.lookup)

Figura 13: Caminho Usado pela Classe Cliente (ic.lookup)

O resultado final é visto após executar a classe Cliente. A figura 14 apresenta o resultado da aba do Glassfish Server, que apresenta os dados dos produtos adicionados ao carrinho.

Dados dos Produtos adicionados ao Carrinho

Figura 14: Dados dos Produtos adicionados ao Carrinho

E por fim na figura15 é apresentado o resultado da aba Cliente, ou seja, o valor final do produto adicionado ao carrinho.

Resultado após a execução da classe cliente

Figura 15: Resultado após a execução da classe cliente

4. Conclusão

Por meio deste artigo conclui-se que a responsabilidade do gerenciamento de passivação e ativação (processos de gravar e recuperar dados respectivamente) ficam com o EJB Container e não com a aplicação em si, facilitando o suporte a transações, invocações remotas, logging, segurança no acesso – caso haja necessidade – e persistência das informações, no modelo apresentado por meio deste documento isso fica a cargo do servidor de aplicações.

5. Bibliografia

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?