Neste artigo serão desenvolvidos dois Sessions Beans, um do tipo Stateless e outro Stateful. O primeiro disponibilizará uma funcionalidade de conversão de câmbio, de dólar para real. O segundo possuirá serviços para realizar a compra da moeda americana.
Esses componentes de negócios serão utilizados por outro sistema, através de acesso remoto.
O IDE utilizado será o Eclipse em sua versão 4.2.2 Juno, com o plugin JBoss AS, para a configuração do servidor.
O primeiro passo é criar um EJB Project, para isso clique com o botão direito do mouse na área de Project Explorer, New -> EJB Project.
Figura 1: Criação do EJB Project no Eclipse
Após isso, um wizard será aberto, assim devemos configurar o nome do projeto e o target runtime que é o servidor de aplicações que iremos utilizar na nosso projeto. Para facilitar a configuração do servidor no Eclipse, foi instalado o plugin do JBoss AS.
Figura 2: Wizard Eclipse para criação do EJB project
Para a configuração do servidor no Eclipse utilizando o plugin, clique no botão “New Runtime...” e escolha dentro da pasta JBoss Comunity a opção JBoss 7.1 Runtime, após isso, clique em next. Na próxima etapa é preciso apontar para a pasta onde o JBoss está instalado.
Figura 3: Configuração do JBoss 7.1 no EJB project
O resultado final é apresentado na Figura 4, onde é possível ver o nome do projeto e a configuração final do servidor. Em seguida basta finalizar a criação.
Figura 4: Configuração final do EJB Project
Após a configuração do servidor, iremos criar os Sessions Beans. Criaremos primeiramente o componente que permite a conversão de câmbio, de dólar para real. Esse é um exemplo extremamente simples, pois o foco do artigo é explorar os conceitos dos tipos de EJBs (Stateless e Stateful) e JNDI, para acesso remoto entre aplicações Java. Conceitos importantes em aplicações distribuídas.
Para criar um Session Bean no Eclipse podemos utilizar um wizard. Ele facilita o processo de criação. Para acessá-lo clique com o botão direito do mouse na pasta ejb-module, que está dentro do projeto EJB e escolha a opção new -> Session Bean (EJB 3.x).
Figura 5: Criação de Stateless Session Beans
Neste wizard é possível configurar Stateless, Stateful e Singleton session beans para acesso Local e/ou Remoto.]
Figura 6: Wizard para criação de Session Bean
Criaremos agora um Stateless Session Bean com acesso Remoto. Para isso, é preciso configurar o pacote e no nome do EJB, na opção “State type”, escolha Stateless e marque o checkbox Remote, para a criação da interface do EJB com a anotação Remote.
Figura 7: Resultado da criação do Session Bean
O resultado da criação é apresentado na Figura 7, a classe CotacaoServices e a interface CotacaoServicesRemote foram criados corretamente.
Na interface CotacaoServicesRemote foi definido um único serviço, o calcular cotação da moeda real, passado um valor em dólar:
Listagem 1: Interface CotacaoServicesRemote
package devmedia.ejb;
import javax.ejb.Remote;
@Remote
public interface CotacaoServicesRemote {
public double calcularCotacaoReal(double valor);
}
A interface está anotada com @Remote para possibilitar o acesso remoto ao EJB. Dessa forma, aplicações executadas em diferentes servidores de aplicações e/ou diferentes máquinas podem utilizar o nosso componente de negócios.
A classe deve implementar a interface e receber a anotação @Stateless, pois essa funcionalidade não precisa manter o estado. O serviço é atômico, ou seja, a conversão é executada para um cliente e logo após finalizada. Desta forma, ficará disponível para que outros clientes possam utilizar o serviço de conversão.
Listagem 2: Classe CotacaoServices
package devmedia.ejb;
import javax.ejb.Stateless;
/**
* Session Bean implementation class CotacaoServices
*/
@Stateless
public class CotacaoServices implements CotacaoServicesRemote {
private static final double COTACAO_DOLAR = 2.05;
public CotacaoServices() {
}
@Override
public double calcularCotacaoReal(double valor) {
return valor*COTACAO_DOLAR;
}
}
O próximo componente que iremos desenvolver neste artigo é um Session Bean Stateful para a compra de dólares. Ele armazena a quantidade de dólares que o usuário irá adquirir e calcular o valor total que o cliente deverá pagar em reais, para isso iremos utilizar o componente de conversão que desenvolvemos anteriormente.
O processo para a construção do EJB Stateful é o mesmo utilizado para o EJB Stateless, a diferença é que no momento da configuração, devemos escolher a opção Stateful ao invés de Stateless:
Figura 8: Criação de EJB Stateful
O Session Bean possui três funcionalidades: adiconar e remover dólares, e calcular o valor total em reais:
Listagem 3: Interface CompraDolarServiceRemote
package devmedia.ejb;
import javax.ejb.Remote;
@Remote
public interface CompraDolarServicesRemote {
public void adicionarDolar(double valor);
public void removerDolar(double valor);
public double calcularValorTotal();
}
A implementação da interface é uma classe EJB anotada com @Stateful, pois para esse serviço, a aplicação deve manter a quantidade de dólares que o usuário deseja comprar, pois cada instância do Session Bean deve atender a um cliente, mantendo a integridade das informações.
Listagem 4: Classe CompraDolarServices
package devmedia.ejb;
import javax.ejb.EJB;
import javax.ejb.Stateful;
/**
* Session Bean implementation class CompraDolarServices
*/
@Stateful
public class CompraDolarServices implements CompraDolarServicesRemote {
private double valor;
@EJB
private CotacaoServicesRemote cotacaoService;
public CompraDolarServices() {
}
@Override
public void adicionarDolar(double pValor) {
valor += pValor;
}
@Override
public void removerDolar(double pValor) {
valor -= pValor;
}
@Override
public double calcularValorTotal() {
return cotacaoService.calcularCotacaoReal(valor);
}
}
Esse EJB depende da funcionalidade do EJB de conversão, assim, foi criado um atributo que referencia a interface remota do EJB de conversão (CotacaoServicesRemote) e ela foi anotada com @EJB para utilizar a injeção de dependência, ou seja, para que o servidor de aplicações coloque uma instância do Session Bean de ConversaoServices neste atributo, depois que o componente de CompraDolarServices for criado.
Esta forma demonstra que a interface de Session Bean anotada com @Remote pode ser utilizada também de forma local, pois, os dois componentes (Conversão e Compra) estão sendo executados no mesmo servidor de aplicações. O contrário não pode ser realizado, pois a interface anotada como @Local não pode ser utilizada para chamadas remotas.
Os dois componentes estão prontos. Agora é necessário executar a aplicação no servidor JBoss AS 7.1. Para isso, iremos executar dentro do próprio Eclipse (é possível também gerar o arquivo .jar e realizar o deploy dentro do servidor). Para isso, clique com o botão direito do mouse no projeto e escolha “Run as” -> “Run on Server”.
Figura 9: Opção para executar o EJB project de dentro do eclipse no JBoss AS 7.1
Se a outra aplicação (Cliente) for acessar o servidor utilizando endereço de IP, é necessário realizar uma configuração no servidor de aplicações. Isso é necessário pois a configuração padrão permite o acesso somente com “localhost”.
Essa configuração é feita no arquivo standalone.xml e pode ser acessado de dentro do Eclipse na aba server -> Filesets -> Configuration File ->>standalone.xml. Este arquivo está presente dentro do jboss, no path JBOSS_HOME/standalone/configuration/.
Figura 10: Arquivo de configuração do JBoss AS7
Neste arquivo, altere a interface public de para :
Listagem 5: Trecho do arquivo standalone.xml
<interfaces>
<interface name="management">
<inet-address value="${jboss.bind.address.management:127.0.0.1}"/>
</interface>
<interface name="public">
<any-address/>
</interface>
<interface name="unsecure">
<inet-address value="${jboss.bind.address.unsecure:127.0.0.1}"/>
</interface>
</interfaces>
Vamos desenvolver uma outra aplicação para utilizar os EJBs de forma remota. Existem duas formas de fazer o acesso remoto, utilizando EJB Client API ou JNDI. Neste artigo vamos utilizar JNDI – Java Naming and Directory Interface para fazer o lookup do nossos Sessions Beans.
No Eclipse, crie um Java Project através do menu file -> new -> Project -> Java Project. Após isso, um wizard de configuração será aberto. Nele é necessário configurar o nome do projeto. O nosso será DevMedia_AcessoRemoto, as outras configurações podemos deixar o padrão.
Figura 11: Criação de um Java Project no Eclipse
O acesso remoto é feito sempre utilizando os contratos dos serviços, ou seja, através das interfaces dos EJBs. Dessa forma, é necessário copiar as interfaces “CompraDolarServicesRemote.java” e “CotacaoServicesRemote.java” para dentro do Java Project criado. É através das interfaces que podemos utilizar RMI (Remote Method Invocation) e invocar os métodos que estão “rodando” em outro servidor, em diferentes máquinas.
Figura 12: Copiando as interfaces dos EJBs
A Figura 12 mostra as interfaces copiadas do projeto EJB, elas apresentam erros, pois utilizam a annotation @Remote do javax.ejb.Remote e não estão presentes no projeto. Para os projetos clientes, podemos adicionar o “jboss-client.jar” no classpath da aplicação. Esse jar está no JBOSS_HOME/bin/client/ e contém todos os elementos que vamos precisar no desenvolvimento. Dessa forma os erros não haverá mais erros.
Para adicionar esse jar no buildpath do projeto, clique com o botão direito do mouse em cima do projeto e acesse o menu Build Path -> Configure Build Path, aa aba “Libraries”, clique em “add External JARs..” e procure pelo jboss-client.jar.
Figura 13: Adicionando o jboss-client.jar no buildpath do projeto
Vamos escrever a classe de teste. O primeiro passo é configurar as propriedades do contexto para fazer o lookup do EJB utilizando JNDI.
JNDI é a API padrão na plataforma Java EE para acesso uniforme a serviços de nomes e diretórios, desta forma é possível acessar diversos sistemas de catálogos, e no nosso caso, será utilizado para localizar os EJBs.
A aplicação cliente deve possuir um arquivo de configuração em seu classpath, chamado jboss-ejb-client.properties. Segue o conteúdo do arquivo para a nossa aplicação:
Listagem 6: Arquivo de configuração da aplicação
endpoint.name=client-endpoint
remote.connectionprovider.create.options.org.xnio.Options.SSL_ENABLED=false
remote.connections=default
remote.connection.default.host=10.2.22.10
remote.connection.default.port = 4447
remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false
remote.connection.default.username=thiagoyama
remote.connection.default.password=123456
A serguir vamos descrever algumas das propriedades:
- endpoint.name: propriedade opcional, caso não seja definida, será utilizado o valor padrão: “config-based-ejb-client-endpoint”. Ela representa o nome do endpoint do lado da aplicação cliente;
- remote.connections: nome da conexão, é utilizado para configurar as conexões. É possível definir várias conexões utilizando nomes diferentes para cada conexão. Ex. remote.connections= conexao1, conexao2;
- remote.connection..host: host do servidor onde a aplicação EJB está executando;
- remote.connection..port: porta para a conexão, por padrão o JBoss AS7 utiliza a 4447;
- remote.connection..username, remote.connection..password: usuário e senha. Elas podem ser criadas através do comando JBOSS_HOME/bin/add-user.sh (ou .bat). Isso é necessário pois a configuração padrão de segurança sercurity-realm está ativada.
- é o nome da conexão definido na propriedade remote.connection.
Vamos criar um usuário para a autenticação do acesso remoto. Acesse o add-user.sh (ou .bat), escolha a opção a, para criar um Management User, deixe em branco o Realm (ManagementRealm). Digite um username e password e finalize:
Figura 14: Criação de um usuário no JBoss AS7
Com a configuração de contexto realizada, poderemos criar o contexto e utilizá-lo para fazer o lookup dos EJBs através do nome JNDI que eles foram publicados no servidor.
O nome de publicação para Stateless Session bean é composto por:
ejb:/// !
O Stateful Session bean segue o mesmo padrão, a diferença é a adição de ?Stateful no final do nome:
ejb:/// !?Stateful
Isso indica que estamos fazendo o lookup de um Stateful Session Bean, possibilitando a criação do bean correto, que deve manter sessão.
Vamos analizar cada parte do nome:
- ejb: é uma constante (não muda), define que é um lookup de EJB;
- app-name: o nome do .ear (sem o sufixo .ear) que contém os EJBs. Se a aplicação não for empacotada em um ear, então basta deixar o app-name vazio;
- module-name: é o nome do .jar ou .war (sem o sufixo .jar ou .war) que contém os EJBs.
- distinct-name: é um nome alternativo que podemos definir. Ela é opcional;
- bean-name: o nome do session bean que queremos fazer o lookup;
- fully-qualified-classname-of-the-remote-interface: o nome e pacote da interface remota que queremos fazer o lookup;
Abaixo está a classe de teste, ela cria o contexto, faz o lookup dos EJBs e invoca os métodos:
Listagm 7: Classe de teste
package devmedia.main;
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import devmedia.ejb.CompraDolarServicesRemote;
import devmedia.ejb.CotacaoServicesRemote;
public class ConsoleViewCotacao {
public static void main(String[] args) throws Exception{
Properties prop = new Properties();
prop.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");
final Context context = new InitialContext(prop);
//Lookup no serviço de cotação remota
CotacaoServicesRemote cotacaoService = CotacaoServicesRemote) context.lookup(
"ejb:/DevMedia_EJB/CotacaoServices!devmedia.ejb.CotacaoServicesRemote");
//Invocando a cotação remota
System.out.println("Cotação: 20 dolares são " + cotacaoService.calcularCotacaoDolar(20) + " reais");
//Lookup no serviço de compra de dolar remota
CompraDolarServicesRemote dolarService = (CompraDolarServicesRemote) context.lookup(
"ejb:/DevMedia_EJB/CompraDolarServices!devmedia.ejb.CompraDolarServicesRemote?stateful");
//Adiciona 40 dolares
dolarService.adicionarDolar(40);
//Calcula o valor total a pagar em reais
System.out.println("Total a pagar: " + dolarService.calcularValorTotal() + " reais");
//Remove 20 dolares
dolarService.removerDolar(20);
//Calcula o valor total a pagar em reais
System.out.println("Total a pagar: " + dolarService.calcularValorTotal() + " reais");
}
}
A classe possui alguns comentários para facilitar o entendimento. Após o lookup, acionamos o método calculaCotacaoDolar() do CotacaoServicesRemote para converter 20 dólares em reais. Depois, utilizamos bean DolarServicesRemote para adicionar 40 dólares ao nosso “carrinho de compras” e calculamos o valor a pagar. Note que após isso, foi invocado o método para removerDolar, onde foram removidos 20 dólares dos 40 já armazenados. E por fim, calculamos novamente o valor total a pagar. Isso demonstra a diferença entre o Stateless e Stateful Session Bean, o primeiro pode ser acessado por vários clientes enquanto que no segundo, cada instância do Session Bean atende a um cliente e pode armazenar informações relativas a ele.
Neste artigo foram discutidos as diferenças entre Sessions Beans do tipo Stateless e Stateful, e o acesso remoto desses Sessions Beans utilizando JNDI. Estes conceitos podem ser bastante úteis no desenvolvimento de aplicações distribuídas, um cenário comum em grandes aplicações corporativas.
