Développement d'applications à l'aide du conteneur d'EJB incorporable

Utilisez cette tâche pour développer des applications à l'aide du conteneur EJB (Enterprise JavaBeans) incorporable. Les applications qui fonctionnent dans un conteneur incorporable démarrent plus rapidement et ont une empreinte plus réduite que lorsqu'elles fonctionnent dans le serveur d'applications complet. L'utilisation de cet environnement est idéal pour développer et tester rapidement des applications qui, à terme, sont destinées à s'exécuter dans un serveur d'applications.

Avant de commencer

Pour créer une application destinée à fonctionner dans le conteneur d'EJB incorporable, vous devez configurer votre environnement de développement pour utiliser la version 8.0 de Java™ Development Kit (JDK) version 1.8 ou ultérieure. Votre environnement de développement doit aussi inclure le fichier JAR (Java archive) du conteneur incorporable de WebSphere dans le chemin de classes. Le fichier com.ibm.ws.ejb.embeddableContainer_9.0.jar se trouve dans le répertoire \runtimes situé sous le répertoire d'installation de WebSphere Application Server.
Restriction : Le client léger d'EJB, com.ibm.ws.ejb.thinclient_9.0.jar, et le fichier JAR incorporable d'EJB, com.ibm.ws.ejb.embeddableContainer_9.0.jar, ne peuvent pas coexister dans le même chemin d'accès aux classes.
Restriction : Le fichier com.ibm.ws.ejb.embeddableContainer_9.0.jar ne fournit les messages qu'en anglais. Si vous avez besoin d'autres langues, utilisez le fichier com.ibm.ws.ejb.embeddableContainer_nls_9.0.jar à la place du fichier com.ibm.ws.ejb.embeddableContainer_9.0.jar. Le fichier com.ibm.ws.ejb.embeddableContainer_nls_9.0.jar se trouve dans le répertoire \runtimes, sous le répertoire d'installation de WebSphere Application Server.

Si vos beans utilisent l'annotation javax.annotation.Resource avec l'attribut de correspondance, vous devez également utiliser le mécanisme Java Endorsed Standards Override Mechanism pour remplacer l'API javax.annotation.Resource disponible dans le JDK que vous utilisez sur votre système. Copiez le fichier app_server_root\runtimes\endorsed\endorsed_apis_9.0.jar dans un répertoire cible de votre choix. Utilisez la propriété java.endorsed.dirs dans la commande Java pour spécifier le répertoire qui contient le fichier JAR copié.

Procédure

  1. Créez un module EJB 3.X. Assurez-vous que le module créé ne contient que des fonctions prises en charge par le conteneur incorporable WebSphere. Pour obtenir la liste complète des fonctions prises en charge, voir la rubrique Fonctions du conteneur incorporable d'EJB. Assurez-vous que les modules EJB se trouvent sur le chemin d'accès aux classes du conteneur incorporable. Chaque module EJB peut être formé de répertoires de classes ou incorporé un JAR d'EJB.
  2. Créez la classe principale qui lance le conteneur incorporable et démarre les méthodes sur les beans enterprise. Utilisez la classe javax.ejb.EJBContainer pour créer une instance du conteneur incorporable (en transmettant éventuellement les paramètres de configuration de conteneur), obtenir le contexte d'affectation de nom de conteneur et fermer le conteneur incorporable.

    L'exemple de code suivant illustre l'utilisation d'un conteneur incorporable :

    //EmbeddableContainerSample.java
    import java.util.HashMap;
    import java.util.Map;
    import javax.ejb.embeddable.EJBContainer;
    import my.pkg.MyBeanIface; // this is the local business interface of the
                               // enterprise bean
    
    public class EmbeddableContainerSample {
    
       public static void main(String[] args) throws Throwable {
    
          // Create a properties map to pass to the embeddable container:
          Map<String,Object> properties = new HashMap<String,Object>();
    
          // Specify that you want to use the WebSphere embeddable container:
          properties.put(EJBContainer.PROVIDER, 
              "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider");
    
          // Create the container instance, passing it the properties map:
          EJBContainer ec = EJBContainer.createEJBContainer(properties);
    
          // Use the container context to look up a bean:
          MyBeanIface bean = ec.getContext().lookup(
              "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface");
    
          // Invoke a method on the bean instance:
          bean.doStuff();
    
          ...
    
    
          // Close the embeddable container:
          ec.close();
    
       }
    }
    

    Dans cet exemple de code, vous avez créé une instance d'un conteneur incorporable en spécifiant la propriété EJBContainer.PROVIDER dans la classe com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider et en transmettant cette propriété à la méthode EJBContainer.createEJBContainer. Vous avez utilisé le contexte d'affectation de nom du conteneur pour rechercher un bean enterprise local (dans cet exemple, MyBean). La recherche (lookup) utilise la syntaxe d'affectation de nom globale portable.

    Cet exemple de code s'appuie sur le conteneur incorporable pour analyser le chemin d'accès aux classes à la recherche du module EJB MyEJBModule. Vous auriez également pu spécifier les modules à démarrer en utilisant la propriété EJBContainer.MODULES. Utilisez cette propriété pour spécifier, sous forme de chaîne ou de tableau de chaînes, la liste des noms des modules qui doivent exister dans le chemin de classes de la JVM.

    Vous pouvez aussi spécifier, dans un objet File ou un tableau d'objets File, les modules qui n'existent pas dans le chemin de classes. Cette technique peut vous obliger à modifier le chargeur de classe de contexte sur l'unité d'exécution courante si les modules désignés nécessitent des bibliothèques supplémentaires qui ne sont pas non plus dans le chemin de classes de la JVM.

    L'exemple de code suivant montre comment démarrer le conteneur incorporable en utilisant un tableau de fichiers.

    ...
    // Create the properties object to pass to the embeddable container:
    Map<String,Object> props = new HashMap<String,Object>();
    
    // Specify the EJB modules to start when creating the container:
    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);
    
    // In this example, both of these modules rely on code in a shared library.
    // In order for the embeddable container to load the shared library, the
    // context classloader must be able to load that shared library.
    
    // Set up the context classloader so that it can load the shared library:
    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);
    
    // Now, create the embeddable container, passing it the properties map:
    EJBContainer ec = EJBContainer.createEJBContainer(props);
    
    // Invoke an EJB loaded by the embeddable container:
    ...

    Après avoir recherché et obtenu l'instance de bean, démarrez des méthodes dessus. Lorsque vous avez terminé les tâches associées au conteneur, fermez celui-ci afin de démarrer les méthodes de bean marquées comme PreDestroy et fermer le conteneur incorporable. Fermez l'instance de conteneur incorporable avant d'en créer une nouvelle.

  3. Personnalisez le conteneur incorporable. Vous pouvez utiliser des propriétés pour personnaliser la phase d'exécution du conteneur incorporable d'EJB. Pour obtenir la liste complète des propriétés prises en charge, voir la rubrique Propriétés personnalisées de conteneur incorporable d'EJB.
  4. Si vous voulez que votre application utilise des ressources telles que des sources de données, vous pouvez les créer et les configurer dans la mappe de propriétés transmise au conteneur conteneur incorporable ou dans un fichier de propriétés.

    L'une des utilisations courantes du conteneur incoporable d'EJB consiste à tester les applications destinées à être exécutées dans le serveur d'applications. Nombre de ces applications sont tributaires de sources de données JDBC qui sont configurées dans le serveur à l'aide de la console d'administration ou de l'outil de création de script wsadmin. Comme ces outils n'existent pas dans le conteneur incorporable WebSphere, vous pouvez configurer celui-ci de manière à pouvoir lui fournir ces ressources en lui passant des propriétés adéquates.

    Les propriétés de configuration d'une source de données peuvent aussi être stockées dans un fichier de propriétés. Le conteneur incorporable charge automatiquement les propriétés stockées dans un fichier nommé embeddable.properties, situé dans le répertoire de travail en cours. Vous pouvez désigner un autre fichier à la place en spécifiant son emplacement et son nom comme valeur de la propriété com.ibm.websphere.embeddable.configFileName.

    Les propriétés de configuration d'une source de données commencent toutes par le préfixe DataSource, suivi d'un terme qui identifie la source de données configurée. Par exemple, DataSource.myDataSource.someProperty et DataSource.anotherDS.someOtherProperty s'appliquent à une autre source de données que DataSource.anotherDS.someOtherProperty. Vous trouverez la liste des propriétés applicables aux sources de données dans la section Propriétés personnalisées du conteneur incorporable d'EJB.

    Voici un exemple d'utilisation de sources de données par une application :

    ...
    InitialContext context = new InitialContext();
    DataSource ds = (DataSource) context.lookup("env/jdbc/AcctsPayableDS");
    Connection conn = ds.getConnection();
    // Use the connection to access the AcctsPayableDS database
    ...

    Dans le serveur, un administrateur système a créé une source de données et l'a liée, dans l'espace de noms JNDI, à env/jdbc/AcctsPayableDS. Le code aurait pu tout aussi bien rechercher la source de données dans un espace de noms java:comp, lequel est mappé à env/jdbc/AcctsPayableDS, ou bien il aurait pu spécifier une zone EJB à injecter avec la source de données. Dans tous les cas, une source de données doit être liée dans l'espace de noms. Utilisez le code suivant pour programmer cette action afin qu'elle ait lieu lors de la création de l'instance de conteneur incorporable :

    ...
    // Create a properties map to store embeddable container config properties
    Map<String,Object> props = new HashMap<String,Object>();
    
    // Set the JNDI name to bind this data source:
    props.put("DataSource.ds1.name", "env/jdbc/AcctsPayableDS");
    
    // Set the data source class name ; this is a required property
    // This example uses a Derby JDBC driver
    props.put("DataSource.ds1.dataSourceClass",
       "org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource");
    
    // Set the database name
    props.put("DataSource.ds1.databaseName", "AcctsPayableTestDB");
    
    // Create the embeddable container instance with our custom properties
    EJBContainer ec = EJBContainer.createEJBContainer(props);
    
    // Now invoke an EJB in the embeddable container...
    ...

    Le code précédent crée une source de données simple, associée à une base de données Apache Derby appelée AcctsPayableTestDB, et la lie à env/jdbc/AcctsPayableDS. Vous pouvez réaliser cette même tâche déclarativement en plaçant le texte suivant dans un fichier nommé embeddable.properties, situé dans le répertoire de travail en cours de la JVM. Vous pouvez aussi placer ce texte dans n'importe quel autre fichier texte et désigner ce fichier dans la propriété système com.ibm.websphere.embeddable.configFileName.

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

    Utilisez des références de ressources lorsque vous développez l'EJB au lieu de rechercher directement des sources de données.

  5. Pour protéger les EJB par un contrôle d'accès à base de rôles, votre application peut utiliser la sécurité à base de rôles Java EE sous une forme à la fois déclarative et programmatique. Vous pouvez effectuer les actions suivantes pour assurer la sécurité d'un EJB en la basant sur des rôles :
    • Définissez un utilisateur à utiliser pour l'autorisation.
    • Affectez aux utilisateurs des rôles déclarés dans votre EJB.
    • Testez l'utilisation des méthodes d'EJBContext isCallerInRole() et getCallerPrincipal() dans votre EJB.

    Voici un exemple montrant comment votre application peut utiliser un mécanisme de sécurité à la fois déclaratif et programmatique :

    import java.util.HashMap;
    import java.util.Map;
    import javax.ejb.EJBContainer;
    import my.pkg.MyBeanIface; // this is the local business interface of the
                               // enterprise bean
    public class EmbeddableContainerSample {
    
       public static void main(String[] args) throws Throwable {
          // Create a properties map to pass to the embeddable container:
          Map<String,Object> properties = new HashMap<String,Object>();
          // Specify that you want to use the WebSphere embeddable container:
          properties.put(EJBContainer.PROVIDER, 
              "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider");
          
          // Specify that you want security checking enabled:
          properties.put("com.ibm.websphere.securityEnabled", "true");
          
          // Assign the users bob, fred, and mary to the role employee:
          props.put("role.employee", "bob, fred, mary");
          // Assign the user fred to the role manager:
          props.put("role.manager", "fred");
          // The user fred will be used for the runAs role manager:
          props.put("role.runAs.manager", "fred");
          // The user fred will be used for role authorization when invoking 
          // methods on the EJB:
          props.put("user.invocation", "fred");
          // Create the container instance, passing it the properties map:
          EJBContainer ec = EJBContainer.createEJBContainer(properties);
          // Use the container context to look up a bean:
          MyBeanIface bean = ec.getContext().lookup(
              "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface");
          // Invoke a method on the bean instance:
          bean.doStuff();
          ...
          // Close the embeddable container:
          ec.close();
       }
    }

    Le code précédent active la sécurité, puis il crée deux rôles, employee et manager, et trois utilisateurs, bob, mary et fred. Il spécifie ensuite que l'utilisateur fred est utilisé pour le rôle d'exécution (runAs) manager. Avant de créer le conteneur incorporable, il établit fred comme utilisateur d'invocation. Cela signifie que lorsque des méthodes de l'EJB sont démarrées, elles le sont par fred. Par conséquent, si ces méthodes requièrent le rôle employee ou manager, fred est en mesure d'y accéder.

  6. Votre application peut spécifier un comportement de confinement de transaction locale (LTC) pour un bean particulier. Pour une explication à ce propos, lisez la section Confinement de transaction locale (LTC).

    Voici un exemple montrant comment votre application peut spécifier le résolveur LTC et l'action non résolue :

    import java.util.HashMap;
    import java.util.Map;
    import javax.ejb.EJBContainer;
    import my.pkg.MyBeanIface; // this is the local business interface 
                               // of the enterprise bean
    
     public class EmbeddableContainerSample {
    
       public static void main(String[] args) throws Throwable {
    
          // Create a properties map to pass to the embeddable container:
          Map<String,Object> properties = new HashMap<String,Object>();
          // Specify that you want to use the WebSphere embeddable container:
          properties.put(EJBContainer.PROVIDER, 
              "com.ibm.websphere.ejbcontainer.EmbeddableContainerProvider");
          
          // Specify that you want the LTC resolver container-at-boundary:
          properties.put("Bean.myApp1#moduleA#bean101.LocalTransaction.Resolver",
                                                          "ContainerAtBoundary");
          
          // Specify that you want the LTC unresolved action commit:
          properties.put("Bean.myApp1#moduleA#bean101.LocalTransaction.UnresolvedAction",
                                                          "Commit");
          
          // Create the container instance, passing it the properties map:
          EJBContainer ec = EJBContainer.createEJBContainer(properties);
          // Use the container context to look up a bean:
          MyBeanIface bean = ec.getContext().lookup(
              "java:global/MyEJBModule/MyBean!my.pkg.MyBeanIface");
          // Invoke a method on the bean instance:
          bean.doStuff();
          ...
          // Close the embeddable container:
          ec.close();
       }
    }

    Le code précédent spécifie, pour le bean concerné, que l'action du résolveur est ContainerAtBoundary (valeur autre que la valeur par défaut) et que l'action non résolue est Commit, qui est l'action autre que par défaut qui valide la transaction.

    Si aucun nom d'application n'est spécifié lors du lancement du conteneur pouvant être imbriqué, la partie <nom_application> doit être omise. Toutefois, vous devez utiliser le délimiteur #. Exemple :
    properties.put("Bean.#moduleA#bean101.LocalTransaction.UnresolvedAction", "Commit"); 

Icône indiquant le type de rubrique Rubrique de tâche



Icône d'horodatage Dernière mise à jour: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tejb_dvemcontainer
Nom du fichier : tejb_dvemcontainer.html