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
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
- 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.
- 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.
- 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.
- 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=AcctsPayableTestDBUse as referências de recurso quando desenvolver o EJB em vez de consultar as origens de dados diretamente.
- 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.
- 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");
Subtópicos
![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Contêiner EJB Integrável
O contêiner Enterprise JavaBeans (EJB) integrável é um contêiner para os enterprise beans que não requerem um Java Platform, Enterprise Edition (Java EE).![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Executando um Contêiner Integrável
Use esta tarefa para executar um contêiner 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.![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Funções do Contêiner EJB Integradas
De acordo com a especificação de Enterprise JavaBeans (EJB) 3.2, todos os contêineres EJB integráveis que os fornecedores usam, devem implementar pelo menos o subconjunto de EJB Lite da funcionalidade EJB. O servidor de aplicativos também contêm recursos adicionais que suportam o subconjunto EJB Lite. Consulte a especificação de EJB 3.2 para obter mais informações.![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Propriedades de Configuração do Contêiner EJB Integrável
Use as seguintes propriedades de configuração para o contêiner Enterprise JavaBeans (EJB) integrável.![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Contêiner EJB Integrável
O contêiner Enterprise JavaBeans (EJB) integrável é um contêiner para os enterprise beans que não requerem um Java Platform, Enterprise Edition (Java EE).![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Executando um Contêiner Integrável
Use esta tarefa para executar um contêiner 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.![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Funções do Contêiner EJB Integradas
De acordo com a especificação de Enterprise JavaBeans (EJB) 3.2, todos os contêineres EJB integráveis que os fornecedores usam, devem implementar pelo menos o subconjunto de EJB Lite da funcionalidade EJB. O servidor de aplicativos também contêm recursos adicionais que suportam o subconjunto EJB Lite. Consulte a especificação de EJB 3.2 para obter mais informações.![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
Propriedades de Configuração do Contêiner EJB Integrável
Use as seguintes propriedades de configuração para o contêiner Enterprise JavaBeans (EJB) integrável.
Tópico de Tarefa
Última atualização: last_datehttp://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-base-dist&topic=tejb_dvemcontainer
Nome do arquivo: tejb_dvemcontainer.html