Introdução ao JBoss


Autor/fonte: Antonio Kantek e Kentaro Takahashi
E-mail/Url: http://www.mundooo.com.br/php/modules.php?name=MOOArtigos&pa=showpage&...
Tags: [ jboss ]



Digg del.icio.us

JBoss é hoje, sem dúvida nenhuma o servidor de aplicação que mais vem chamando a atenção no mundo J2EE. Várias características fazem dele uma opção inteligente. Neste artigo vamos mostrar um pouco de sua história, vamos mostrar como instalá-lo, configurá-lo além de alguns exemplos.

O JBoss existe desde 1999. No começo ele se chamava EJBoss ou EJB Open Source Server. Mas por motivos legais, seu nome ficou apenas JBoss (que na minha opinião é muito melhor). Ele é desenvolvido por um time de primeira liderado pelo francês Marc Fleury (estamos falando do JBoss Group). Vamos ver os primeiros passos necessários para implantármos nele um componente EJB. A nova arquitetura é toda baseada em JMX (Java Management Extension). Ao contrário da maioria de seus concorrentes que são implementados em um gingantesco bloco monolítico, o JBoss possui um microkernel baseado em JMX. Cada componente do servidor de aplicação é um componente JMX (ou melhor, um MBean). Originalmente criado para gerênciar redes, o JMX permite o mapeamento de componentes através de nomes. Os componentes são mapeados por nomes em um servidor de MBeans. A chamada de um método de um MBean deve ser feita indicando-se o nome do MBean, o nóme do método e os parâmetros. Um pequeno exemplo da vantagem de um servidor de aplicação baseado em JMX e open source é a facilidade de substituição de um componente.

Instalação

Podemos baixar o JBoss de dois lugares: do próprio site do JBoss ou podemos baixá-lo do SourceForge onde ele está hospedado. No SourceForge podemos encontrar ainda slides de apresentações da JBossOne (evento realizado pelos desenvolvedores do JBoss, o JBossGroup), quickstarts, códigos fonte e patchs . Sugerimos ao leitor que baixe em seu computador o JBoss 3.0.x, pois são as versões quem implementam a especificação J2EE 1.3 (que contém a especificação EJB 2.0). Atualize a sua variável de ambiente CLASSPATH com os arquivos jar contido em $JBOSS_DIST/client ($JBOSS_DIST é utilizado para simbolizar o diretório onde foi descompactado o JBoss). Esses novos arquivos jar adicionados na variável CLASSPATH contém todas classes necessárias para que o usuário utilize este servidor de aplicação.

O JBoss vem com um banco de dados relacional escrito em Java, o Hypersonic SQL. Isso facilita a vida do desenvolvedor na hora de testar seus Entity Beans, eliminando assim o trabalho de configurar uma nova base de dados. Instalar uma nova base de dados no JBoss é extramemente fácil. A configuração e instalação de uma base de dados é feita através de um arquivo xml. No diretório $JBOSS_DIST/docs/examples/jca existem vários moldes de arquivos de configuração.

Para WebContainer podemos optar entre Tomcat e Jetty. A grande sugestão fica por conta do Jetty (também um MBean) que possue uma ótima integração com o JBoss, ambos podem rodar na mesma Java Virtual Machine.

Configurando e iniciando

Para iniciarmos o JBoss, basta ir no diretório $JBOSS_DIST/bin e executar o arquivo de lote run. Para os usuários do Windows a linha de comando é %JBOSS_DIST%\bin\run.bat e para os usuários do Linux a linha é $JBOSS_DIST/bin/run.sh . Para visualizarmos o estado dos componentes do JBoss (os MBeans), devemos abrir um browser no endereço http://localhost:8082. O endereço padrão do WebServer (Jetty ou Tomcat) é http://localhost:8080. Na versão 3.0.2 em diante o endereço para visualisármos os componentes JMX é http://localhost:8080/jmx-console.

Podemos escolher a configuração do servidor escolhendo uma padrão ou criando uma personalizada. O JBoss vem com três configurações padrão: mínima (minimal), padrão (default) e completa (all). Estas configurações estão em $JBOSS_DIST/server. O usuário pode criar ainda a sua própria configuração, bastando para isso apenas criar um novo diretório junto com as outras configurações. É sempre melhor criar a sua própria configuração, pois isso facilita manutenção.

A configuração mínima contém apenas os serviços mais básicos como log e servidor de nomes (JNDI). Nesta configuração não há EJB Container, serviço de mensagens (MOM Message Oriented Middleware) ou clustering. Na configuração padrão (default), todos os serviços estão disponíveis (transação, mensagens, EJB Container etc) exceto clustering e RMI-IIOP (Remote Method Invocation over Internet Inter-ORB Protocol, o protocolo utilizado pelo CORBA). Ou seja, na configuração padrão, os serviços CORBA não estão disponíveis. E para finalizar, na configuração completa (all), todos os serviços especificados pelo J2EE v1.3 estão disponíveis.

Para iniciarmos o JBoss com alguma configuração desejada basta passarmos o nome da configuração como parâmetro do arquivo run. Por exemplo: run.sh -c nome_da_configuração.

Criando um componente EJB HelloWorld

Vamos fazer uma rápida revisão de EJB antes de mostrarmos o exemplo “Hello World”. Grandes aplicações necessitam de certos serviços de middleware como: objetos distribuídos (possibilidade de um objeto se comunicar com outro objeto em outra máquina), balanceamento de carga (distribuir os processos de forma que nenhum servidor trabalhe mais que outros), transparência a falhas (caso um servidor falhe, outro deve imediatamente responder por ele) e pool de objetos (reaproveitamento do mesmo objeto por vários usuários para economia de memória). O desenvolvedor de componentes EJB deve se preocupar apenas com regras de negócios e não com serviços de middleware. Pois quem se responsabiliza por este último é o servidor de aplicação.

Os componentes EJB vivem em EJB Containers. Os EJB Containers são responsáveis pelo ciclo de vida dos componentes EJB, além disso, eles também controlam os serviços de middleware como iniciar transação ou verificar direitos (segurança). Existem basicamente 3 tipos de componentes EJB: Session Beans (podem ser com ou sem estado), Entity Beans (componentes que representam entidades persistentes do sistema) e MessageDriven Beans (componentes que são executados apartir de mensagens). Os Session Beans representam ações no sistema, essas ações podem conter estado (Session Bean Stateful) ou não (Session Bean Stateless). Um exemplo de um Session Bean com estado é o famoso carrinho de compras de um sistema de comércio eletrônico. E um exemplo de um Session Bean sem estado é um componente que cataloga um novo usuário no sistema. Os Entity Beans representam as entidades do sistema, os sujeitos. São persistentes e sua persistência pode ser gerenciada pelo Container (Entity Bean CMP - Container Managed Persistence) ou não, ou seja, quem vai se responsabilizar pela persistência é o próprio componente (Entity Bean BMP - Bean Managed Persistence). Os MessageDriven Beans são componentes EJB parecidos com os Session Beans Stateless, porém eles são movidos a mensagens, ou seja, eles apenas processam mensagens. Essas mensagens podem ser mensagens JMS (Java Message Service) ou futuramente mensagens enviadas via WebServices (Especificação EJB 2.1). Todo componente EJB deve possuir pelo menos um nome JNDI para que este possa ser localizado. O serviço de nomes JNDI mapeia um recurso dado um nome. Podemos mapear um diretório, um arquivo, um componente EJB, um DataSource (configuração de banco de dados) ou ainda uma conexão com um serviço de mensagens.

A anatomia de um componente EJB é composta de uma Component e Home interface, um EnterpriseBean Object, chave primária se for um Entity Bean, o deployment descriptor (arquivo xml com todas as configurações do componente) e arquivos específicos de cada servidor de aplicação. A exceção fica por conta dos MessageDriven Beans que possuem apenas o EnterpriseBean Object (a implementação).

A Component e a Home interface podem ser locais (apenas acessíveis por objetos que estão rodando na mesma máquina Java) ou remotos (acessíveis por qualquer objeto via RMI-IIOP). O EnterpriseBean Object é o objeto que implementa (não diretamente) as interfaces Component e Home. A chave primária pode ser um tipo simples como Integer, Double, Long ou BigDecimal ou um tipo composto. O tipo composto é implementado por um objeto Java que possui os atributos necessários para a chave composta além dos métodos hashCode e equals implementados, este objeto deve implementar a interface java.io.Serializable, ou seja, tem que ser um objeto serializável.

Não existe exemplo introdutório mais didático ao aprendermos uma tecnologia (linguagem ou ferramenta) nova do que o famoso “Hello World”. Na listagem 1 é mostrado o código da Component interface (remota) do componente EJB. Esta interface contém apenas a assinatura dos métodos de negócio. A classe que irá implementar diretamente esta interface será providenciada pelo EJB Container, o trabalho desta classe é chamar os serviços de middleware ( como transação e segurança ) antes de chamar a implementação verdadeira, que no nosso caso é o código que a implementação do método de negócio hello que está na classe HelloWorldBean. Esta interface pode ser considerada um proxy para o EnterpriseBean Object. Na listagem 2 temos a implementação (o EnterpriseBean Object) do EJB HelloWorld, além desta classe implementar os métodos descritos na interface SessionBean, ela ainda possui a implementação dos métodos da Component e da Home interface. A Home interface possui apenas a descrição de um método que cria componentes EJB HelloWorld. O deployment descriptor (listagem 4) é o mesmo para todos os servidores de aplicação. Nele nós descrevemos característica como transação, tipo de persistência, segurança e relacionamento entre os componentes EJB. Aqui neste exemplo estamos apenas indicando quais são as classes utilizadas pelo componente EJB e o tipo de transação. Neste exemplo estamos utilizando a configuração Container, ou seja, a persistência vai ser gerenciada pelo container e não pelo componente (transação declarativa). O arquivo jboss.xml (listagem 5) é um arquivo específico do JBoss e nele nós estamos dando um nome JNDI para o nosso componente HelloWorld. Em seguida (listagem 6) nós temos um código cliente que imprime no console o resultado do método hello. E por último (listagem 7), temos um arquivo de propriedades com os dados necessários para localizarmos uma instância do JBoss residente Na mesma máquina do cliente.

Executando o método hello do componente HelloWorld

O JBoss permite comunicação através de RMI puro ao invés de RMI-IIOP. Isso é uma vantagem quando o código cliente é um programa Java. O ORB (Object Request Broker) do JBoss na versão 3.x é o JacORB, sendo este também open source. O ORB é utilizado pelos objetos distribuídos para que estes se localizem e se comuniquem entre si. Através do JacORB, o JBoss também permite comunicação por RMI-IIOP (Entenda RMI-IIOP como interface RMI implementada pelo protocolo de comunicação IIOP ( o utilizando no CORBA). Essencial quando necessitamos de performance ou quando o nosso cliente não é Java. Além disso, a especificação J2EE não é flexível, ela exige que a comunicão seja feita por RMI-IIOP. O JBoss permite comunicação por RMI simples.

Aqui neste exemplo utilizaremos RMI simples. Vamos criar o arquivo jar com os códigos compilados. Podemos criar este arquivo através do Ant. O Ant (uma ferramenta para geração de builds) permite entre outras tarefas, empacotar classes em arquivos jar. A grande novidade fica por conta do diretório META-INF. Além do arquivo MANIFEST.MF, este terá os arquivos ejb-jar.xml (descritor de implantação ou deployment descriptor) e o arquivo específico do JBoss, o jboss.xml.

Pronto, agora temos o nosso arquivo jar prontinho para ser instalado no JBoss. Para fazermos um deploy no JBoss (instalar algum componente no servidor de aplicação), basta apenas iniciar o servidor com a configuração desejada (devemos lembrar o leitor que a configuração só não pode ser a minimal, pois esta não possue EJB Container) e em seguida arrastar e soltar o arquivo jar no seguinte diretório: $JBOSS_DIST/server/ configuração_desejada.

Para executarmos o método hello do componente EJB HelloWorld, basta acessarmos o serviço de nomes JNDI do JBoss através das propriedades mostradas na figura 7. Em seguida localizamos o componente (operação de lookup) através de seu nome. A parte do componente que é mapeada é a Home interface. Repare que para fazermos o casting do objeto recuperado para HelloWorldHome, utilizamos o método narrow da classe PortableRemoteObject. Isso se deve ao fato que a especificação EJB diz que a comunicação deve ser feita por IIOP. É dessa forma que fazemos castings. Para saber mais sobre IIOP ou CORBA, visite http://www.omg.org. A Object Management Group é organização que define as especificações do CORBA.

Localizada a Home interface (ou melhor o objeto fornecido pelo EJB Container que implementa diretamente a Home interface), é hora de criarmos um componente HelloWorld através do método create. Feito isso podemos executar o método hello do nosso componente HelloWorld. E por último, é aconselhado chamar o método remove de Session Beans.

Para saber mais

Existem algumas ferramentas excelentes para a construção de aplicações J2EE. A seguir:

- Ant: para criação do projeto (compilação, geração de stubs, geração de arquivos JAR etc);
- Xdoclet: cria arquivos redundantes como os arquivos de configuração do servidor de aplicação, as Component e Home interfaces, value objects (objetos com todos os atributos do entity bean, utilizado para diminuir o tráfego na rede) e chaves primárias. Estes arquivos são criados através da implementação do componente EJB (EnterpriseBean Object) e de tags específicas inseridas nos comentários (javadocs);
- JUnit: utilizado para testes;
- JEdit: poderoso editor grátis com código fonte disponível. O forte do JEdit são seus plugins que permitem entre outros: editar/navegar em arquivos XML, executar comandos SQL em um banco de dados relacional, Class Browser para visualizar todas as classes carregadas e o Code Aid para mostrar todos os métodos disponíveis da classe ou do objeto.

Os códigos fontes das listagens a seguir podem ser obtidos aqui.

Listagem 1 - Component interface para o componente EJB HelloWorld:

import java.rmi.RemoteException;
import javax.ejb.EJBObject;

 /**
 * Exemplo básico de Session Bean.
 * Imprime no console a frase 'Hello World'
 */

public interface HelloWorld extends EJBObject {
       String helloWorld() throws RemoteException;
}

Listagem 2 - Implementação do Session BeanHello World:

import javax.ejb.CreateException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;

 /**
 * EnterpriseBean Object para o EJB HelloWorld
 */

public class HelloWorldBean implements SessionBean {
       protected SessionContext ctx;

       public void setSessionContext(SessionContext ctx) {
              this.ctx = ctx;
       }

       public void ejbCreate() throws CreateException {
       }

       public void ejbActivate() {
       }     

       public void ejbPassivate() {
       }

       public void ejbRemove() {
       }

       public String helloWorld() {
              return “HelloWorld”;
       }
}

Listagem 3 - Implementação do Home interface para o componente EJB HelloWorld:

import javax.ejb.CreateException;
import javax.ejb.EJBHome;
import java.rmi.RemoteException;

/**
 * Home interface para o EJB HelloWorld
 */

public interface HelloWorldHome extends EJBHome {
       HelloWorld create() throws CreateException;
}

Listagem 4 - Listagem do deployment descriptor para esta aplicação:

<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar>
     <description>Hello World, o meu primeiro EJB!!!</description>
     <display-name>HelloWorld</display-name>
     <enterprise-beans>
       <session>
         <ejb-name>HelloWorld</ejb-name>
         <home>HelloWorldHome</home>
         <remote>HelloWorld</remote>
         <ejb-class>HelloWorldBean</ejb-class>
         <session-type>Stateless</session-type>
         <transaction-type>Container</transaction-type>
       </session>
      </enterprise-beans>
</ejb-jar>

Listagem 5 - Listagem do arquivo jboss.xml, arquivo específico do JBoss que contém entre outros a configuração dos nomes jndi para os componentes EJB:

<?xml version="1.0" encoding="UTF-8"?>
<jboss>
  <enterprise-beans>
    <session>
      <ejb-name>HelloWorld</ejb-name>
      <jndi-name>HelloWorld</jndi-name>
    </session>
  </enterprise-beans>

Listagem 6 - Listagem de um código cliente:

import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.rmi.PortableRemoteObject; 

public class HelloWorldClient {
       public static void main(String[] args) throws Exception {
              Properties props = new Properties();
              props.load( HelloWorldClient.class.getResourceAsStream("jboss.jndi") );
              Context ctx = new InitialContext( props ); 
              Object ref = ;
              HelloWorldHome home = (HelloWorldHome) PortableRemoteObject.narrow( ctx.lookup("HelloWorld"), server.HelloWorldHome.class  );
              HelloWorld helloWorld = home.create();
              System.out.println( helloWorld.hello() );
              helloWorld.remove();
       }
}

Listagem 7 - Propriedades necessárias para localizar o JBoss e seu serviço de nomes (arquivo jboss.jndi):

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory

java.naming.provider.url=localhost:1099

java.naming.factory.url.pkgs=org.jboss.naming

Considerações finais

Existem inúmeras razões para adotarmos um servidor de aplicação distribuído pela licença LGPL (http://www.gnu.org para saber mais sobre esta licença), mas a principal razão é: qualquer um pode participar deste projeto (reportando bugs, fazendo sugestões ou ainda enviando códigos) isso faz com que o projeto sempre esteja disponível. Centenas de desenvolvedores no mundo inteiro estão trabalhando nele. Diferente de produtos comerciais, onde a existência do produto depende de uma só empresa. Se esta desistir dele, ninguém mais dará suporte.

Já existem casos de sucesso onde a adoção do JBoss foi fundamental para a sobrevivência da empresa. Se formos ver bem, os servidores de aplicação não custam tão caro assim, se levarmos em conta o que eles fazem. Mas não podemos negar que o JBoss é uma opção muito mais realista para o mercado Brasileiro.

E para finalizar, o JBoss é um servidor de aplicação muito fácil de utilizar, ainda mais se compararmos com seus concorrentes. É muito fácil instalar componentes EJB ou recursos J2EE como DataSources (arquivos de configuração de banco de dados) e isso graças ao seu Hot Deployer. Por exemplo, basta um drag'n'drop de um arquivo jar com componentes EJB que estes já estão funcionando.




Enviado por xKuRt em 13/05/2007 às 19:47


Itens relacionados

Instalação do Jboss no Fedora 8

Avaliação

Avaliação desta publicação: 10.00; Total de avaliações: 1


Avaliar:


A avaliação de publicações é restrita a membros cadastrados e logados no nosso site.



Comentários

AvatarEnviado por chucky515 em 14/01/2013 às 12:03

bem completinho gostei vlw


Envio de comentário:




  

Sexta, 25 de Julho de 2014




Top 5 membros

Últimos membros online

Últimos membros cadastrados



Capa do livro
Google Top 10 - Como Colocar seu Site ou Blog na Primeira Página do Google


Capa do livro
BI - Businnes Intelligence no Excel


Capa do livro
Java e Web para Concursos





Hostnet

IMD