Criando um projeto EJB no NetBeans

Criando o módulo EJB

Para começar crie um Novo Projeto, na aba Categorias selecione Java EE e na aba Projetos selecione Módulo EJB, conforme a figura ProjetoEJB01.

Clique em Próximo > para continuar a criação do projeto. Na tela de Novo Módulo EJB apresentada na figura a seguir, no campo Nome do projeto digite HelloWorldEJB e informe o Local do projeto de sua preferência.

Clique em Próximo > para continuar a criação do projeto. Agora selecione o Servidor que será usado para publicar o projeto EJB nesse exemplo usaremos o Glassfish Server 3.1 e a Versão do Java EE usada será a Java EE 6, conforme a figura a seguir:

Clique em Finalizar para terminar a criação do projeto. A Figura a seguir apresenta como é a estrutura inicial do projeto gerado pelo NetBeans:

Criando um EJB Stateless Session Bean

Crie a interface HelloWorldRemote no pacote pbc.ejb e adicione a assinatura do método public abstract String ola().

package pbc.ejb;

import javax.ejb.Remote;

@Remote
public interface HelloWorldRemote {
    public abstract String ola();
}

Nesta interface adicione a anotação @Remote para informar que ela será acessada remotamente.

Agora vamos implementar esta interface, crie uma classe chamada HelloWorldBean no mesmo pacote e implemente o método ola().

package pbc.ejb;

import javax.ejb.Stateless;

@Stateless
public class HelloWorldBean implements HelloWorldRemote {
    public String ola() {
        return "Ola mundo com EJB.";
    }
}

Nesta classe adicione a anotação @Stateless para informar que ela será um componente EJB do tipo Stateless Session Bean.

Publicando o projeto EJB no Glassfish

Após criar o projeto EJB é necessário publicá-lo em um servidor web para poder acessar os componentes EJB. Para isso clique com o botão direito sobre o projeto HelloWorldEJB e escolha a opção Implantar, conforme a Figura ProjetoEJB05; se o servidor web GlassFish não estiver iniciado, o NetBeans irá iniciá-lo e publicará o projeto EJB nele.

Depois que terminar de iniciar o Glassfish, aparecerá a seguinte mensagem no console de saída:

INFO: Portable JNDI names for EJB HelloWorldBean :
[java:global/HelloWorldEJB/HelloWorldBean!pbc.ejb.HelloWorldRemote,
java:global/HelloWorldEJB/HelloWorldBean]
INFO: Glassfish-specific (Non-portable) JNDI names for EJB
HelloWorldBean : [pbc.ejb.HelloWorldRemote#pbc.ejb.HelloWorldRemote,
pbc.ejb.HelloWorldRemote]
INFO: HelloWorldEJB was successfully deployed in 11.478
milliseconds.

Caso ocorra algum problema ao tentar publicar a aplicação no servidor web GlassFish, será apresentado neste console as mensagens dos erros.

Criando um Projeto Java Console para testar o EJB

Para testar o componente EJB crie um projeto console. No NetBeans crie um Novo projeto, na aba Categorias selecione Java, e na aba Projetos selecione Aplicativo Java e clique em Próximo, conforme a figura a seguir:

Na janela Novo Aplicativo Java, deixe o Nome do projeto como HelloWorld e na Localização do projeto, defina a mesma pasta que foi criado o projeto EJB HelloWorldEJB, conforme a figura a seguir:

Antes de começar a desenvolver o cliente do EJB, é necessário adicionar algumas bibliotecas (jar) no projeto, estas bibliotecas serão utilizadas para fazer o lookup do EJB.

Clique com o botão direito no projeto HelloWorld e escolha o item Propriedades. Na tela de Propriedades do projeto, apresentada na figura a seguir, selecione a categoria Bibliotecas e clique no botão Adicionar JAR / Pasta.

Na janela Adicionar JAR / Pasta navegue até a pasta de instalação do Glassfish e entre no diretório /glassfish-vX/glassfish/modules/, conforme apresentado na figura a seguir:

Selecione gf-client.jar ou gf-client-module.jar e clique em Selecionar.

Também é preciso adicionar uma referência entre os projetos. Na mesma tela de Biblioteca, clique no botão Adicionar projeto... e selecione o projeto HelloWorldEJB e clique em OK. Esta referência entre os projetos serve para referenciar as classes e interfaces, como, por exemplo, a interface HelloWorldRemote.

Na pasta Pacotes de códigos-fontes, crie a classe TesteEJB no pacote pbc.teste, que será utilizada para testar o EJB HelloWorldRemote.

package pbc.teste;

import pbc.ejb.HelloWorldRemote;
import javax.naming.InitialContext;
import javax.naming.NamingException;

/**
 * Classe utilizada para testar o EJB de HelloWorldRemote.
 */
public class TesteEJB {
  public static void main(String[] args) {
    try {
      //Método que faz o lookup para encontrar o EJB de HelloWorldRemote.
      InitialContext ctx = new InitialContext();
      HelloWorldRemote ejb = (HelloWorldRemote) ctx.lookup
        ("pbc.ejb.HelloWorldRemote");

      System.out.println(ejb.ola());

    } catch (NamingException ex) {
      ex.printStackTrace();
      System.out.println("Não encontrou o EJB.");
    } catch (Exception ex) {
      ex.printStackTrace();
      System.out.println(ex.getMessage());
    }
  }
}

No método main() foi criado um objeto do tipo javax.naming.InitialContext que possui o método lookup utilizado para obter uma instância do EJB, após pedir uma instância do EJB ctx.lookup("pbc.ejb.HelloWorldRemote") é chamado o método ola(), que devolve a mensagem definida no componente EJB.

Repare que para pedir um EJB para o GlassFish é utilizado o método lookup passando o nome completo da classe remota do EJB, também é possível fazer o lookup especificando o projeto e módulo, por exemplo: java:global[/<app-name>]/<module-name>/<bean-name>.

A figura a seguir apresenta a estrutura atual do projeto.

Testando o EJB

Para testar o EJB, execute a classe TesteEJB do projeto HelloWorld. Será apresentada a seguinte saída no console.

Ola mundo com EJB.

Se o Glassfish estiver instalado em outra maquina ou a porta padrão 3700 for alterada é possível criar um arquivo de propriedades através da classe java.util.Properties para definir estas informações, como por exemplo:

package pbc.teste;

import pbc.ejb.HelloWorldRemote;
import java.util.Properties;
import javax.naming.InitialContext;
import javax.naming.NamingException;

/**
 * Classe utilizada para testar o EJB de HelloWorldRemote.
 */
public class TesteEJB {
  public static void main(String[] args) {
    try {
      /* Monta um objeto Properties com as informações 
        para localizar o Glassfish. */
      Properties props = new Properties();
      props.put("org.omg.CORBA.ORBInitialHost", "localhost");
      props.put("org.omg.CORBA.ORBInitialPort", "3700");

      /* Método que faz o lookup para encontrar o EJB 
        de HelloWorldRemote. */
      InitialContext ctx = new InitialContext(getProperties());
      HelloWorldRemote ejb = (HelloWorldRemote) ctx.lookup
        ("pbc.ejb.HelloWorldRemote");

      System.out.println(ejb.ola());
    } catch (NamingException ex) {
      ex.printStackTrace();
      System.out.println("Não encontrou o EJB.");
    } catch (Exception ex) {
      ex.printStackTrace();
      System.out.println(ex.getMessage());
    }
  }
}

Melhorando o lookup

Para melhorar a forma de fazer lookup existe um padrão de projeto chamado Service Locator, que consiste em deixar genérica a forma como é feito o lookup do EJB.

O padrão Service Locator serve para separar a lógica envolvida no lookup das classes que precisam utilizar o EJB.

A seguir, será criada uma classe chamada ServiceLocator, está classe será responsável por fazer um lookup de forma genérica, note que a natureza desta classe é altamente coesa, ou seja seu objetivo é bem definido: fazer o lookup do EJB.

package pbc.util;

import java.util.Properties;
import javax.naming.InitialContext;

/**
 * Classe utilizada para fazer um lookup genérico do EJB.
 */
public class ServiceLocator {

  /**
   * Propriedades do Glassfish.
   */
  private static Properties properties = null;

  /**
   * Monta um objeto Properties com as informações para 
   * localizar o glassfish.
   * @return
   */
  private static Properties getProperties() {
    if (properties == null) {
      properties = new Properties();
      properties.put("org.omg.CORBA.ORBInitialHost", "localhost");
      properties.put("org.omg.CORBA.ORBInitialPort", "3700");
    }
    return properties;
  }

  /**
   * Método que faz o lookup generico de um EJB.
   *
   * @param <T>
   * @param clazz - Classe que representa a interface do 
   *   EJB que será feito o lookup.
   * @return
   * @throws Exception
   */
  public static <T> T buscarEJB(Class<T> clazz) throws Exception {
    /* Cria o initial context que faz via JNDI a procura do EJB. */
    InitialContext ctx = new InitialContext(getProperties());

    /* Pega o nome completo da interface utilizando 
      reflection, faz o lookup do EJB e o retorno do EJB. */
    return (T) ctx.lookup(clazz.getName());
  }
}

Agora a classe que utiliza o EJB, não precisa mais saber como fazer o lookup do EJB, precisa apenas chamar o método buscarEJB da classe ServiceLocator passando como parâmetro a Class da interface do EJB.

package pbc.teste;

import pbc.ejb.UsuarioRemote;
import aula.util.ServiceLocator;

/**
 * Classe utilizada para testar o EJB de HelloWorldRemote.
 */
public class TesteEJB {
  public static void main(String[] args) {
    try {
      HelloWorldRemote ejb = (HelloWorldRemote)
        ServiceLocator.buscarEJB(HelloWorldRemote.class);

      System.out.println(ejb.ola());
    } catch (Exception ex) {
      System.out.println(ex.getMessage());
    }
  }
}

Existem outras vantagens de utilizar o Service Locator para separar a lógica do lookup, por exemplo: um Proxy para caso seja necessário gravar algum log quando criar o EJB ou quando seus métodos são chamados.