Desenvolvendo Aplicativos Usando o Contêiner EJB Integrável

Use esta tarefa para desenvolver aplicativos usando o contêiner Enterprise JavaBeans (EJB) integrável. Aplicativos que executam no contêiner integrável começam mais rápida e precisam de uma área de cobertura menor do que quando executam no servidor de aplicativos integral. Este é um ambiente otimizado para desenvolver e testar aplicativos rapidamente que podem eventualmente executar no servidor de aplicativos.

Antes de Iniciar

Para criar um aplicativo de contêiner EJB integrado, você deve configurar seu ambiente de desenvolvimento para utilizar a Versão 8.0 do Java™ Development Kit (JDK) Versão 1.8 ou superior. O seu ambiente de desenvolvimento também deve incluir o arquivo Java archive (JAR) do contêiner integrável do WebSphere no caminho da classe. O arquivo com.ibm.ws.ejb.embeddableContainer_9.0.jar está localizado no diretório \runtimes no diretório de instalação do WebSphere Application Server.
Restrição: O thin client EJB, com.ibm.ws.ejb.thinclient_9.0.jar, e o arquivo JAR integrado EJB, com.ibm.ws.ejb.embeddableContainer_9.0.jar, não podem coexistir no mesmo caminho de classe.
Restrição: O arquivo com.ibm.ws.ejb.embeddableContainer_9.0.jar limita-se a fornecer mensagens em inglês. Se for necessário suporte para idiomas adicionais, utilize o arquivo com.ibm.ws.ejb.embeddableContainer_nls_9.0.jar no lugar do com.ibm.ws.ejb.embeddableContainer_9.0.jar. O com.ibm.ws.ejb.embeddableContainer_nls_9.0.jar está localizado no diretório \runtimes no diretório de instalação do WebSphere Application Server.

Se os beans usarem a anotação javax.annotation.Resource com o atributo de consulta, você deverá usar também o Java Endorsed Standards Override Mechanism para substituir a API javax.annotation.Resource que está disponível no JDK no seu sistema. Copie o arquivo app_server_root\runtimes\endorsed\endorsed_apis_9.0.jar em um diretório de destino da sua opção. Use a propriedade java.endorsed.dirs no comando Java para especificar seu diretório que contém o arquivo JAR copiado.

Procedimento

  1. Crie um módulo EJB 3.X. Ao criar esse módulo, você deve certificar-se de que ele contém apenas recursos que são suportados pelo contêiner integrável do WebSphere. Para obter uma lista de funções suportadas, consulte o tópicoFunções do Contêiner EJB Integradas. Certifique-se de que os módulos EJB estão no caminho da classe do contêiner integrável. É possível compactar o módulo EJB com diretórios de classes ou como arquivos EJB JAR.
  2. Crie a classe principal que ativa o contêiner integrável e que inicia os métodos nos enterprise beans. Use a classe javax.ejb.EJBContainer para criar uma instância do contêiner integrável (opcionalmente passando parâmetros de configuração do contêiner), obtenha o contexto de nomenclatura do contêiner e feche o contêiner integrável.

    O código de amostra a seguir ilustra o uso do contêiner integrável:

    //EmbeddableContainerSample.java
    import java.util.HashMap;
    import java.util.Map;
    import javax.ejb.embeddable.EJBContainer;
    import my.pkg.MyBeanIface; // essa é a interface de negócios local do
                               // enterprise bean
    
    public class EmbeddableContainerSample {
    
       public static void main(String[] args) throws Throwable {
    
          // Crie um mapa de propriedades para passar para o contêiner integrável:
          Map<String,Object> properties = new HashMap<String,Object>();
    
          // Especifique que deseja usar o contêiner integrável do WebSphere:
          properties.put(EJBContainer.PROVIDER, 
              "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider");
    
          // Crie a instância do contêiner, passando-a o mapa de propriedades:
          EJBContainer ec = EJBContainer.createEJBContainer(properties);
    
          // Use o contexto do contêiner para consultar um bean:
          MyBeanIface bean = ec.getContext().lookup(
              "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface");
    
          // Chame um método na instância do bean:
          bean.doStuff();
    
          ...
    
    
          // Feche o contêiner integrável:
          ec.close();
    
       }
    }
    

    Nesse código de amostra, você criou uma instância de um contêiner integrável especificando a propriedade EJBContainer.PROVIDER para a classe com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider, e passando essa propriedade para o método EJBContainer.createEJBContainer. Você usou o contexto de nomenclatura do contêiner para consultar um enterprise bean local, por exemplo, MyBean. A consulta usa a sintaxe de nomenclatura global móvel.

    Esse código de amostra conta com o contêiner integrável para automaticamente varrer o caminho da classe para localizar o módulo EJB, MyEJBModule. Como alternativa, você pode ter especificado os módulos desejados para iniciar usando a propriedade EJBContainer.MODULES. Use essa propriedade para especificar uma sequência ou matriz de sequência de nomes de módulo para devem existir no caminho da classe JVM.

    Também é possível especificar um arquivo ou matriz de arquivos de módulos que não existem no caminho da classe. Essa abordagem de arquivo ou matriz de arquivos requer que você modifique o carregador de classes de contexto no encadeamento atual, se esses módulos precisam de bibliotecas adicionais que também não estão no caminho da classe JVM.

    O exemplo de código a seguir ilustra como iniciar o contêiner integrável usando uma matriz de arquivo.

    ...
    // Crie um mapa de propriedades para passar para o contêiner integrável:
    Map<String,Object> props = new HashMap<String,Object>();
    
    // Especifique os módulos EJB para iniciarem quando o contêiner for criado:
    File[] ejbModules = new File[2];
    ejbModules[0] = new File("/home/myusername/ejbs/ShoppingCartEJB.jar");
    ejbModules[1] = new File("/home/myusername/ejbs/OnlineCatalogEJB.jar");
    props.put(EJBContainer.MODULES, ejbModules);
    
    // Nesse exemplo, esses dois módulos contam com o código em uma biblioteca compartilhada.
    // Para que o contêiner integrável carregue a biblioteca compartilhada, o
    // carregador de classe deve poder carregar essa biblioteca compartilhada.
    
    // Configure o carregador de classe de contexto para que ele possa carregar a biblioteca compartilhada:
    File sharedLibUtilityFile = new File("/home/myusername/ejbs/SharedLib.jar");
    ClassLoader oldCL = Thread.currentThread().getContextClassLoader();
    ClassLoader newCL = new URLClassLoader(new URL[]{
       sharedLibUtilityFile.toURI().toURL()}, oldCL);
    Thread.currentThread().setContextClassLoader(newCL);
    
    // Agora, crie o contêiner integrável, passando-a o mapa de propriedades:
    EJBContainer ec = EJBContainer.createEJBContainer(props);
    
    // Chame um EJB carregado pelo contêiner integrável:
    ...

    Depois de consultar a interface do bean, inicie os métodos nela. Quando terminar as tarefas relacionadas ao contêiner, feche o contêiner, que inicia os métodos de bean marcados como PreDestroy e fecha o contêiner integrável. Feche a instância do contêiner integrável antes de criar uma nova.

  3. Customize o contêiner integrável. É possível usar as propriedades para customizar o tempo de execução de contêiner EJB integrável. Para obter uma lista completa de propriedades suportadas, consulte o tópico Propriedades Customizadas do Contêiner EJB Integrável.
  4. Se desejar que o seu aplicativo use recursos como origens de dados, então é possível criar e configurar esses recursos no mapa de propriedades passado para o contêiner integrável ou em um arquivo de propriedades.

    Um uso comum do contêiner EJB integrável é testar aplicativos que eventualmente executam no servidor de aplicativos. Muitos desses aplicativos dependem das origens de dados do JDBC que estão configuradas no servidor usando o console administrativo ou a ferramenta de script wsadmin. Como essas ferramentas não existem no contêiner integrável, é possível configurar o contêiner integrável do WebSphere para fornecer esses recursos passando propriedades para ele.

    As propriedades de configuração da origem de dados também podem ser armazenadas em um arquivo de propriedades. O contêiner integrável automaticamente carrega propriedades armazenadas em um arquivo chamado embeddable.properties no diretório atualmente em funcionamento. É possível substituir o local desse arquivo especificando o novo local do arquivo como o valor da propriedade do sistema com.ibm.websphere.embeddable.configFileName.

    Todas as propriedades de configuração da origem de dados iniciam com DataSource e são seguidas por um termo que identifica qual origem de dados está sendo configurada. Por exemplo, DataSource.myDataSource.someProperty aplica-se a uma origem de dados diferente da origem denominada DataSource.anotherDS.someOtherProperty. A lista de propriedades da origem de dados está localizada nas informações de propriedades customizadas do contêiner EJB integrável.

    Aqui está um exemplo de como o seu aplicativo pode usar origens de dados:

    ...
    InitialContext context = new InitialContext();
    DataSource ds = (DataSource) context.lookup("env/jdbc/AcctsPayableDS");
    Connection conn = ds.getConnection();
    // Use a conexão para acessar o banco de dados AcctsPayableDS
    ...

    No servidor, um administrador do sistema criou uma origem de dados e a limitou ao namespace JNDI para env/jdbc/AcctsPayableDS. Como alternativa, o código pode ter consultado a origem de dados em um namespace java:comp, que é mapeado para env/jdbc/AcctsPayableDS, ou especificado um campo EJB para ser injetado com a origem de dados. Em todos os casos, uma origem de dados deve ser limitada no namespace. Use o seguinte código para concluir essa ação programaticamente ao criar a instância do contêiner integrável:

    ...
    // Crie um mapa de propriedade para armazenar propriedades de configuração do contêiner integrável
    Map<String,Object> props = new HashMap<String,Object>();
    
    // Configure o nome de JNDI para ligar essa origem de dados:
    props.put("DataSource.ds1.name", "env/jdbc/AcctsPayableDS");
    
    // Configure o nome de classe da origem de dados; essa é uma propriedade necessária
    // Esse exemplo usa um driver JDBC do Derby
    props.put("DataSource.ds1.dataSourceClass",
       "org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource");
    
    // Configure o nome do banco de dados
    props.put("DataSource.ds1.databaseName", "AcctsPayableTestDB");
    
    // Crie a instância do contêiner integrável com nossas propriedades customizadas
    EJBContainer ec = EJBContainer.createEJBContainer(props);
    
    // Agora chame um EJB no contêiner integrável...
    ...

    O código precedente cria uma origem de dados simples para um banco de dados Apache Derby chamado AcctsPayableTestDB e liga-a em env/jdbc/AcctsPayableDS. Essa mesma tarefa pode ser concluída de modo declarativo ao colocar o seguinte texto em um arquivo chamado embeddable.properties no diretório de trabalho atual da JVM. Também é possível colocar esse texto em qualquer arquivo de texto, e especificar esse arquivo de texto na propriedade de sistema com.ibm.websphere.embeddable.configFileName.

    DataSource.ds1.name=env/jdbc/AcctsPayableDS
    DataSource.ds1.dataSourceClass=org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource
    DataSource.ds1.databaseName=AcctsPayableTestDB

    Use as referências de recurso quando desenvolver o EJB em vez de consultar as origens de dados diretamente.

  5. O seu aplicativo pode usar segurança baseada em função Java EE, tanto declarativa quanto programática, para verificar a sua segurança baseada em função EJB. É possível concluir as seguintes ações para verificar a segurança baseada em função EJB:
    • Definir um usuário para ser usado para propósitos de autorização.
    • Designar usuários para funções que são declaradas no seu EJB.
    • Testar o uso dos métodos EJBContext, isCallerInRole() e getCallerPrincipal(), no seu EJB.

    Aqui está um exemplo de como o seu aplicativo pode usar segurança declarativa e programática:

    import java.util.HashMap;
    import java.util.Map;
    import javax.ejb.EJBContainer;
    import my.pkg.MyBeanIface; // essa é a interface de negócios local do
                               // enterprise bean
    public class EmbeddableContainerSample {
    
       public static void main(String[] args) throws Throwable {
          // Crie um mapa de propriedades para passar para o contêiner integrável:
          Map<String,Object> properties = new HashMap<String,Object>();
          // Especifique que deseja usar o contêiner integrável do WebSphere:
          properties.put(EJBContainer.PROVIDER, 
              "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider");
          
          // Especifique que deseja verificação de segurança ativada:
          properties.put("com.ibm.websphere.securityEnabled", "true");
          
          // Designe os usuários bob, fred e mary para o funcionário da função:
          props.put("role.employee", "bob, fred, mary");
          // Designe o usuário fred para o gerente da função:
          props.put("role.manager", "fred");
          // O usuário fred será usado para o gerente da função runAs:
          props.put("role.runAs.manager", "fred");
          // O usuário fred será usado para autorização de função ao chamar 
          // métodos no EJB:
          props.put("user.invocation", "fred");
          // Crie a instância do contêiner, passando-a o mapa de propriedades:
          EJBContainer ec = EJBContainer.createEJBContainer(properties);
          // Use o contexto do contêiner para consultar um bean:
          MyBeanIface bean = ec.getContext().lookup(
              "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface");
          // Chame um método na instância do bean:
          bean.doStuff();
          ...
          // Feche o contêiner integrável:
          ec.close();
       }
    }

    O código anterior ativa a segurança e depois cria duas funções, employee e manager, e três usuários, bob, mary, e fred. Ele então especifica que o usuário fred é usado ao executar como a função manager. Antes de criar o contêiner integrável, ele configura o usuário da chamada como fred. Isso significa que quando os método EJB são iniciados, eles são iniciados por fred, que significa que se esses métodos requererem a função de employee ou manager, fred poderá acessar esses métodos.

  6. O seu aplicativo pode especificar o comportamento Local Transaction Containment (LTC) por bean. Para obter uma explicação da LTC, leia sobre a restrição de transação local.

    Aqui está um exemplo de como o seu aplicativo pode especificar o resolvedor LTC e a ação não resolvida:

    import java.util.HashMap;
    import java.util.Map;
    import javax.ejb.EJBContainer;
    import my.pkg.MyBeanIface; // essa é a interface de negócios local do 
                               // enterprise bean
    
     public class EmbeddableContainerSample {
    
       public static void main(String[] args) throws Throwable {
    
          // Crie um mapa de propriedades para passar para o contêiner integrável:
          Map<String,Object> properties = new HashMap<String,Object>();
          // Especifique que deseja usar o contêiner integrável do WebSphere:
          properties.put(EJBContainer.PROVIDER, 
              "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider");
          
          // Especifique que deseja o contêiner na delimitação do resolvedor LTC:
          properties.put("Bean.myApp1#moduleA#bean101.LocalTransaction.Resolver",
                                                          "ContainerAtBoundary");
          
          // Especifique que deseja a confirmação da ação não resolvida do LTC:
          properties.put("Bean.myApp1#moduleA#bean101.LocalTransaction.UnresolvedAction",
                                                          "Commit");
          
          // Crie a instância do contêiner, passando-a o mapa de propriedades:
          EJBContainer ec = EJBContainer.createEJBContainer(properties);
          // Use o contexto do contêiner para consultar um bean:
          MyBeanIface bean = ec.getContext().lookup(
              "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface");
          // Chame um método na instância do bean:
          bean.doStuff();
          ...
          // Feche o contêiner integrável:
          ec.close();
       }
    }

    O código anterior define a ação do resolvedor para o bean especificado para seu valor não padrão de contêiner na delimitação, e faz com que a ação não resolvida seja a ação não padrão que confirma a transação.

    Se um nome do aplicativo não for especificado ao lançar o contêniner incorporável, a <application_name> deve ser omitida. Porém, você deve usar o delimitador #. Por exemplo:
    properties.put("Bean.#moduleA#bean101.LocalTransaction.UnresolvedAction", "Commit"); 

Ícone que indica o tipo de tópico Tópico de Tarefa



Ícone de registro de data e hora Última atualização: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tejb_dvemcontainer
Nome do arquivo: tejb_dvemcontainer.html