Desarrollo de aplicaciones con el contenedor EJB incorporable
Utilice esta tarea para desarrollar aplicaciones con el contenedor EJB (Enterprise JavaBeans) incorporable. Las aplicaciones que se ejecutan en el contenedor incorporable se inician más rápidamente y requieren menos espacio que cuando se ejecutan en el servidor de aplicaciones completo. Es un entorno óptimo para desarrollar y probar rápidamente aplicaciones que finalmente se podrían ejecutar en el servidor de aplicaciones.
Antes de empezar
Si los beans utilizan la anotación javax.annotation.Resource con el atributo de búsqueda, también debe utilizar el mecanismo Java Endorsed Standards Override Mechanism para alterar temporalmente la API javax.annotation.Resource que está disponible en el JDK en el sistema. Copie el archivo raíz_servidor_apl\runtimes\endorsed\endorsed_apis_9.0.jar en un directorio de destino de su elección. Utilice la propiedad java.endorsed.dirs en el mandato Java para especificar el directorio que contiene el archivo JAR copiado.
Procedimiento
- Cree el módulo EJB 3.X. Al crear este módulo, asegúrese de que sólo contiene las características que están soportadas por el contenedor incorporable de WebSphere. Para obtener una lista completa de las funciones admitidas, consulte el tema Funciones de contenedor EJB incorporables. Asegúrese de que los módulos EJB están en la classpath del contenedor incorporable. Puede empaquetar el módulo EJB como directorios de clases o como archivos JAR EJB.
- Cree la clase principal que inicia el contenedor incorporable e
inicia métodos en los enterprise beans. Utilice la clase javax.ejb.EJBContainer para crear una instancia del contenedor
incorporable (puede pasar opcionalmente los parámetros de configuración del
contenedor), obtener el contexto de denominación del contenedor y cerrar el
contenedor incorporable.
En el código de ejemplo siguiente se ilustra el uso del contenedor incorporable:
//EmbeddableContainerSample.java import java.util.HashMap; import java.util.Map; import javax.ejb.embeddable.EJBContainer; import my.pkg.MyBeanIface; // esta es la interfaz de empresa local del // enterprise bean public class EmbeddableContainerSample { public static void main(String[] args) throws Throwable { // Crear una correlación de propiedades para pasar al contenedor incorporable: Map<String,Object> properties = new HashMap<String,Object>(); // Especificar que desea utilizar el contenedor incorporable de WebSphere: properties.put(EJBContainer.PROVIDER, "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider"); // Crear la instancia de contenedor, pasarla a la correlación de propiedades: EJBContainer ec = EJBContainer.createEJBContainer(properties); // Utilizar el contexto de contenedor para buscar un bean: MyBeanIface bean = ec.getContext().lookup( "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface"); // Invocar un método en una instancia de bean: bean.doStuff(); ... // Cerrar el contenedor incorporable: ec.close(); } }
En este código de ejemplo, ha creado una instancia de un contenedor incorporable especificando la propiedad EJBContainer.PROVIDER a la clase com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider y pasando dicha propiedad al método EJBContainer.createEJBContainer. Ha utilizado el contexto de denominación del contenedor para buscar un enterprise bean local, por ejemplo, MyBean. La búsqueda utiliza la sintaxis de denominación global portable.
Este código de ejemplo se basa en el contenedor incorporable para explorar automáticamente la classpath para buscar el módulo EJB, MyEJBModule. O bien puede haber especificado los módulos que desea iniciar utilizando la propiedad EJBContainer.MODULES. Utilice esta propiedad para especificar una serie o una matriz de series de nombres de módulo que deben existir en la classpath de la JVM.
También puede especificar un archivo o matriz de archivos de módulos que no exista en la variable classpath. Este enfoque de archivo o matriz de archivos podría requerir la modificación del cargador de clases de contexto en la hebra actual, si estos módulos necesitan bibliotecas adicionales que tampoco están en la classpath de la JVM.
En el ejemplo de código siguiente se muestra cómo iniciar el contenedor incorporable utilizando una matriz de archivos.
... // Crear el objeto de propiedades para pasarlo al contenedor incorporable: Map<String,Object> props = new HashMap<String,Object>(); // Especificar los módulos EJB que se deben iniciar cuando se crea el contenedor: 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); // En este ejemplo, estos dos módulos dependen de código en una biblioteca compartida. // Para que el contenedor incorporable cargue la biblioteca compartida, el // cargador de clases de contexto debe poder cargar la biblioteca compartida. // Configurar el cargador de clases de contexto para que pueda cargar la biblioteca compartida: 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); // Ahora, crear el contenedor incorporable, pasándole la correlación de propiedades: EJBContainer ec = EJBContainer.createEJBContainer(props); // Invocar un EJB cargado por el contenedor incorporable: ...
Después de buscar la instancia de bean, inicie métodos en ella. Cuando termine las tareas relacionadas con el contenedor, cierre el contenedor, que inicia los métodos de bean marcados como PreDestroy y cierra el contenedor incorporable. Cierre la instancia del contenedor incorporable antes de crear una de nueva.
- Personalice el contenedor incorporable. Puede utilizar propiedades para personalizar el tiempo de ejecución del contenedor EJB incorporable. Para obtener una lista completa de las propiedades soportadas, consulte el tema Propiedades personalizadas de contenedor EJB incorporable.
- Si desea que la aplicación utilice recursos como orígenes de datos, puede crear y configurar dichos recursos en la correlación de propiedades pasada al contenedor incorporable o en un archivo de propiedades.
Un uso común del contenedor EJB incorporable es el de probar aplicaciones que se acaban ejecutando en el servidor de aplicaciones. Muchas de estas aplicaciones dependen de orígenes de datos JDBC que se configuran en el servidor mediante la consola administrativa o la herramienta de scripts wsadmin. Dado que estas herramientas no existen en el contenedor incorporable, puede configurar el contenedor incorporable de WebSphere para proporcionar estos recursos pasándole propiedades.
Las propiedades de configuración de origen de datos también se pueden almacenar en el archivo de propiedades. El contenedor incorporable carga automáticamente propiedades almacenadas en un archivo denominado embeddable.properties en el directorio de trabajo actual. Puede alterar temporalmente esta ubicación de archivo especificando la ubicación del nuevo archivo como valor de la propiedad del sistema com.ibm.websphere.embeddable.configFileName.
Todas las propiedades de configuración de orígenes de datos empiezan por DataSource y siguen con término que identifica qué fuente de datos se está configurando. Por ejemplo, DataSource.myDataSource.someProperty se aplica a un origen de datos diferente de uno denominado DataSource.anotherDS.someOtherProperty. La lista de las propiedades de origen de datos se encuentra en la información sobre las propiedades personalizadas del contenedor EJB incorporable.
A continuación se muestra un ejemplo de cómo la aplicación puede utilizar orígenes de datos:
... InitialContext context = new InitialContext(); DataSource ds = (DataSource) context.lookup("env/jdbc/AcctsPayableDS"); Connection conn = ds.getConnection(); // Utilizar la conexión para acceder a la base de datos AcctsPayableDS ...
En el servidor, un administrador de sistemas ha creado un origen de datos y lo ha enlazado en el espacio de nombres JNDI a env/jdbc/AcctsPayableDS. De forma alternativa, el código podría haber buscado el origen de datos en un espacio de nombres java:comp, que se correlaciona conenv/jdbc/AcctsPayableDS, o haber especificado un campo EJB para inyectarlo con el origen de datos. En todos los casos, un origen de datos debe estar enlazado en el espacio de nombres. Utilice el código siguiente para completar esta acción mediante programación cuando cree la instancia de contenedor incorporable:
... // Crear una correlación de propiedades para almacenar la propiedades de configuración del contenedor incorporable Map<String,Object> props = new HashMap<String,Object>(); // Establecer el nombre JNDI para enlazar este origen de datos: props.put("DataSource.ds1.name", "env/jdbc/AcctsPayableDS"); // Establecer el nombre de la clase del origen de datos; esta propiedad es necesaria // En este ejemplo se utiliza un controlador JDBC Derby props.put("DataSource.ds1.dataSourceClass", "org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource"); // Establecer el nombre de la base de datos props.put("DataSource.ds1.databaseName", "AcctsPayableTestDB"); // Crear la instancia del contenedor incorporable con las propiedades personalizadas EJBContainer ec = EJBContainer.createEJBContainer(props); // Ahora, invocar un EJB en el contenedor incorporable... ...
El código anterior crea un origen de datos simple a una base de datos Apache Derby denominada AcctsPayableTestDB y lo enlaza a env/jdbc/AcctsPayableDS. Puede realizar esta misma tarea de forma declarativa colocando el texto siguiente en un archivo denominado embeddable.properties en el directorio de trabajo actual de la JVM. También puede colocar este texto en cualquier archivo de texto y especificar ese archivo de texto en la propiedad del sistema com.ibm.websphere.embeddable.configFileName.
DataSource.ds1.name=env/jdbc/AcctsPayableDS DataSource.ds1.dataSourceClass=org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource DataSource.ds1.databaseName=AcctsPayableTestDB
Utilice referencias de recursos al desarrollar el en lugar de buscar directamente fuentes de datos.
- La aplicación puede utilizar la seguridad basada en roles de Java EE, tanto declarativa y como mediante programación, para verificar la seguridad basada en roles de EJB. Puede realizar las acciones siguientes para verificar la seguridad basada en roles de EJB:
- Definir un usuario que se utilizará para fines de autorización.
- Asignar usuarios a roles que se declaran en el EJB.
- Probar el uso de los métodos EJBContext, isCallerInRole() y getCallerPrincipal() en el EJB.
El ejemplo siguiente muestra cómo la aplicación puede utilizar la seguridad declarativa y mediante programación:
import java.util.HashMap; import java.util.Map; import javax.ejb.EJBContainer; import my.pkg.MyBeanIface; // esta es la interfaz de empresa local del // enterprise bean public class EmbeddableContainerSample { public static void main(String[] args) throws Throwable { // Crear una correlación de propiedades para pasar al contenedor incorporable: Map<String,Object> properties = new HashMap<String,Object>(); // Especificar que desea utilizar el contenedor incorporable de WebSphere: properties.put(EJBContainer.PROVIDER, "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider"); // Especificar que desea habilitar la comprobación de la seguridad: properties.put("com.ibm.websphere.securityEnabled", "true"); // Asignar los usuarios bob, fred y mary al rol employee: props.put("role.employee", "bob, fred, mary"); // Asignar el usuario fred al rol manager: props.put("role.manager", "fred"); // El usuario fred se utilizará para el rol runAs manager: props.put("role.runAs.manager", "fred"); // El usuario fred se utilizará para la autorización de roles al // invocar métodos en el EJB: props.put("user.invocation", "fred"); // Crear la instancia de contenedor, pasarla a la correlación de propiedades: EJBContainer ec = EJBContainer.createEJBContainer(properties); // Utilizar el contexto de contenedor para buscar un bean: MyBeanIface bean = ec.getContext().lookup( "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface"); // Invocar un método en una instancia de bean: bean.doStuff(); ... // Cerrar el contenedor incorporable: ec.close(); } }
El código anterior habilita la seguridad y, a continuación, crea dos roles, employee y manager, y tres usuarios, bob, mary y fred. A continuación, especifica que el usuario fred se utiliza cuando se ejecuta como el rol manager. Antes de crear el contenedor incorporable, establece el usuario de invocación como fred. Esto significa que, cuando se inician métodos de EJB, se inician mediante fred, lo que significa que si estos métodos requieren el rol de employee o manager, fred puede acceder a estos métodos.
- La aplicación puede especificar el comportamiento de contenedor de transacciones locales (LTC) para cada bean. Para obtener una explicación de LTC, lea la información acerca del contenedor de transacciones locales.
El ejemplo siguiente muestra cómo la aplicación puede especificar el solucionador de LTC y la acción no resuelta:
import java.util.HashMap; import java.util.Map; import javax.ejb.EJBContainer; import my.pkg.MyBeanIface; // esta es la interfaz de empresa local // del enterprise bean public class EmbeddableContainerSample { public static void main(String[] args) throws Throwable { // Crear una correlación de propiedades para pasar al contenedor incorporable: Map<String,Object> properties = new HashMap<String,Object>(); // Especificar que desea utilizar el contenedor incorporable de WebSphere: properties.put(EJBContainer.PROVIDER, "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider"); // Especificar que desea el solucionador de LTC container-at-boundary: properties.put("Bean.myApp1#moduleA#bean101.LocalTransaction.Resolver", "ContainerAtBoundary"); // Especificar que desea la acción no resuelta de LTC commit: properties.put("Bean.myApp1#moduleA#bean101.LocalTransaction.UnresolvedAction", "Commit"); // Crear la instancia de contenedor, pasarla a la correlación de propiedades: EJBContainer ec = EJBContainer.createEJBContainer(properties); // Utilizar el contexto de contenedor para buscar un bean: MyBeanIface bean = ec.getContext().lookup( "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface"); // Invocar un método en una instancia de bean: bean.doStuff(); ... // Cerrar el contenedor incorporable: ec.close(); } }
El código anterior establece la acción del solucionador para el bean especificado en su valor no predeterminado de container-at-boundary y hace que la acción no resuelta sea la acción no predeterminada que confirma la transacción.
Si el nombre de la aplicación no se especifica cuando se inicia el contenedor incorporable, <nombre_aplicación> deberá omitirse. No obstante, se debe utilizar el delimitador #. Por ejemplo:properties.put("Bean.#moduleA#bean101.LocalTransaction.UnresolvedAction", "Commit");
Subtopics
Contenedor EJB incorporable
El contenedor de EJB (Enterprise JavaBeans) incorporable es un contenedor para enterprise beans que no necesitan Java Platform, Enterprise Edition (Java EE).Ejecución de un contenedor incorporable
Utilice esta tarea para ejecutar un contenedor incorporable. Las aplicaciones que se ejecutan en el contenedor incorporable se inician más rápidamente y requieren menos espacio que cuando se ejecutan en el servidor de aplicaciones completo. Es un entorno ideal para desarrollar y probar rápidamente aplicaciones que finalmente se podrían ejecutar en el servidor de aplicaciones.Funciones de contenedor EJB incorporables
De acuerdo con la especificación de Enterprise JavaBeans (EJB) 3.2, todos los contenedores EJB que se pueden incorporar que utilizan los proveedores deben implementar, al menos, un subconjunto de EJB Lite de las funciones EJB. El servidor de aplicaciones también contiene características adicionales que admiten el subconjunto EJB Lite. Consulte la especificación de EJB 3.2 si desea más información.Propiedades de configuración del contenedor EJB incorporable
Utilice las siguientes propiedades de configuración del contenedor EJB (Enterprise JavaBeans) incorporable.Contenedor EJB incorporable
El contenedor de EJB (Enterprise JavaBeans) incorporable es un contenedor para enterprise beans que no necesitan Java Platform, Enterprise Edition (Java EE).Ejecución de un contenedor incorporable
Utilice esta tarea para ejecutar un contenedor incorporable. Las aplicaciones que se ejecutan en el contenedor incorporable se inician más rápidamente y requieren menos espacio que cuando se ejecutan en el servidor de aplicaciones completo. Es un entorno ideal para desarrollar y probar rápidamente aplicaciones que finalmente se podrían ejecutar en el servidor de aplicaciones.Funciones de contenedor EJB incorporables
De acuerdo con la especificación de Enterprise JavaBeans (EJB) 3.2, todos los contenedores EJB que se pueden incorporar que utilizan los proveedores deben implementar, al menos, un subconjunto de EJB Lite de las funciones EJB. El servidor de aplicaciones también contiene características adicionales que admiten el subconjunto EJB Lite. Consulte la especificación de EJB 3.2 si desea más información.Propiedades de configuración del contenedor EJB incorporable
Utilice las siguientes propiedades de configuración del contenedor EJB (Enterprise JavaBeans) incorporable.


http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tejb_dvemcontainer
File name: tejb_dvemcontainer.html