Implémentation de vues RESTful d'un EJB avec des interfaces locales

Si vous disposez d'applications Enterprise JavaBeans (EJB) qui sont exposées à l'aide d'une vue d'interface locale, vous pouvez exposer une interface RESTful au bean enterprise à l'aide de l'API JAX-RS (Java™ API for RESTful Web Services). En implémentant des beans enterprise annotés, vous conservez les fonctionnalités des EJB, y compris la prise en charge des transactions, l'injection de composants et de ressources Java EE, ainsi que d'autres fonctions de bean session EJB.

Avant de commencer

Avant EJB 3.1, les beans enterprise nécessitant une vue client locale EJB avaient aussi besoin d'une interface Java séparée, généralement située dans un fichier distinct, qui déclarait les méthodes de vue locale. Le bean enterprise spécifiait qu'il implémentait l'interface de vue locale EJB à l'aide de descripteurs de déploiement ou d'annotations EJB.

Grâce à la spécification EJB 3.1, vous avez la possibilité d'exposer une vue locale d'un bean enterprise sans interface locale EJB explicite. En effet, le bean enterprise dispose d'une vue client sans interface basée sur les méthodes publiques de votre classe de bean. Il peut être plus simple de développer des beans enterprise de vue sans interface qu'un bean enterprise de vue locale pour les raisons suivantes :
  • Les beans enterprise de vue sans interface ne nécessitent pas de déclaration d'interface Java distincte.
  • Les beans enterprise de vue sans interface ne nécessitent pas la spécification de métadonnées supplémentaires dans le descripteur de déploiement ou lors de l'utilisation d'annotations.
Consultez la spécification EJB 3.1 pour de plus amples informations sur les vues sans interface d'un bean enterprise.

JAX-RS prend en charge l'utilisation de beans enterprise déclarant une interface métier locale et des beans enterprise de vue sans interface.

Cette tâche décrit l'implémentation de vues RESTful d'un bean enterprise avec une interface locale pour permettre au bean enterprise d'exposer des ressources JAX-RS.

Pourquoi et quand exécuter cette tâche

Vous pouvez créer un bean enterprise simple avec des annotations JAX-RS. Même si cette tâche explique spécifiquement comment implémenter des vues RESTful d'un bean enterprise de vue d'interface locale, il est important de prendre en compte la totalité de la portée de votre architecture d'application et le mode d'exposition souhaité lors du choix du modèle de ressource et de l'identification des vues RESTful convenant à l'application des beans enterprise. Ces considérations n'entrent pas dans le périmètre de cette tâche.

JAX-RS prend en charge les beans session sans état et de type singleton. Vous pouvez ajouter des annotations JAX-RS à l'interface locale d'un bean session. De plus, avec EJB 3.1, vous pouvez ajouter des annotations JAX-RS directement dans une classe EJB si un bean enterprise expose une vue sans interface.

Avec les règles de mise en forme EJB 3.1, vous pouvez ajouter des beans enterprise JAX-RS dans le fichier WAR (fichier d'archive d'application Web) directement dans le répertoire WEB-INF/classes ou à l'aide d'un fichier JAR (fichier d'archive Java) dans le répertoire WEB-INF/lib. Vous pouvez déclarer un bean enterprise à l'aide d'annotation ou d'un descripteur de déploiement EJB, ou en utilisant à la fois des annotations et un descripteur de déploiement.

Les beans enterprise annotés JAX-RS dans un fichier autonome ou un fichier JAR d'EJB distinct non inclus dans un fichier EAR ne sont pas pris en charge.

Pratiques recommandées Pratiques recommandées: Même si vous pouvez déclarer des beans enterprise de différentes manières, il est conseillé d'implémenter directement l'interface métier locale EJB et de toujours déclarer l'annotation @javax.ejb.Local. Avec cette méthode, le bean EJB doit implémenter l'interface métier locale, ce qui évite les erreurs de saisie de noms de méthode et de modifications de type d'argument. En utilisant toujours l'annotation @javax.ejb.Local, dans le cas de plusieurs interfaces métier, il suffit d'ajouter l'interface métier à la valeur d'annotation. Vous pouvez également utiliser cette approche pour modifier le bean enterprise à l'aide d'un descripteur de déploiement.bprac

Procédure

  1. Créez des interfaces locales de bean enterprise pour votre application de bean enterprise. L'exemple suivant illustre une interface métier locale simple, l'interface locale EJB Purchasable pour l'achat d'articles.
    package com.example.jaxrs;
    @javax.ws.rs.Path("itemsForPurchase/{itemID}")
    public interface Purchasable {
    
        public int getItemsLeft(String itemID);
    
        @javax.ws.rs.POST
        public Order purchase(
            @javax.ws.rs.PathParam("itemID") String itemID,
            @javax.ws.rs.QueryParam("orderId") String orderID);
    }

    La méthode getItemsLeft est une méthode EJB classique non liée à JAX-RS. Une annotation javax.ws.rs.Path indique le chemin de requête HTTP à utiliser. Lorsqu'une requête HTTP POST est exécutée sur l'objet itemsForPurchase/{itemID}, l'environnement d'exécution JAX-RS recherche un bean EJB implémentant l'interface locale Purchasable et appelle la méthode purchase sur le bean enterprise.

    Vous pouvez toujours utiliser la méthode purchase en dehors d'une demande d'environnement d'exécution JAX-RS. Vous pouvez utiliser une injection ou une recherche JNDI pour un bean enterprise purchasable et appeler la méthode purchase avec les deux arguments de chaîne itemID et orderID.

    Pratiques recommandées Pratiques recommandées: Si plusieurs beans enterprise implémentent une interface métier locale, l'environnement d'exécution JAX-RS sélectionne un bean EJB aléatoire à utiliser lorsqu'une demande JAX-RS est effectuée. Il est conseillé de n'activer qu'une seule classe de bean pour implémenter une interface locale EJB annotée JAX-RS. Si nécessaire, créez une interface locale EJB distincte, utilisez les annotations JAX-RS sur la nouvelle interface, puis modifiez la classe de bean pour qu'elle implémente la nouvelle interface locale EJB. bprac
  2. Créez un bean enterprise qui implémente l'interface métier locale. L'exemple suivant illustre le bean EJB Purchasable :
        public int getItemsLeft(String itemID) {
            // Return the number of items left.  
        }
    
        public Order purchase(String itemID, String orderId) {
            // Add the given item to the order id and return it.  
        }
    
    }
  3. Déclarez que la classe Book est un bean enterprise et qu'elle implémente une interface locale. Utilisez l'une des méthodes suivantes pour déclarer votre classe en tant que bean enterprise qui implémente l'interface locale. Dans l'exemple suivant, la classe Book est déclarée en tant que bean enterprise qui implémente une interface locale.
    • Utilisez l'annotation EJB @javax.ejb.Stateless ou @javax.ejb.Singleton sur la classe Book pour indiquer que l'EJB doit être sans état ou de type singleton. En outre, ajoutez l'annotation @javax.ejb.Local avec les interfaces locales comme valeur d'annotation. Par exemple :
      @javax.ejb.Stateless
      @javax.ejb.Local(Purchasable.class)
      public class Book {
      Si vous avez implémenté plusieurs interfaces métier locales, ajoutez les classes d'interface à la valeur d'annotation @javax.ejb.Local. Par exemple :
      @javax.ejb.Local({Purchasable.class, Rentable.class})
    • Vous pouvez utiliser un descripteur de déploiement pour déclarer un bean EJB et les interfaces métier qu'il implémente. Par exemple :
      <ejb-jar xmlns="http://java.sun.com/xml/ns/javaee" version="3.1"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/ejb-jar_3_1.xsd">
      <!--
          This file must exist in the WEB-INF/
          directory of your WAR file. See EJB 3.1 spec 20.4 for more details.
      -->
          <enterprise-beans>
              <session>
                  <ejb-name>Book</ejb-name>
                  <business-local>com.example.jaxrs.Purchasable</business-local>
                  <ejb-class>com.example.jaxrs.Book</ejb-class>
                  <session-type>Stateless</session-type>
              </session>
          </enterprise-beans>
      </ejb-jar>

      Si vous avez implémenté plusieurs interfaces métier locales, vous devez ajouter des éléments métier locaux à chaque interface locale dans votre définition de bean.

    • Dans le cas d'une seule interface métier locale, vous pouvez implémenter directement l'interface. Par exemple :
      @javax.ejb.Stateless
      public class Book implements Purchasable {
  4. (Facultatif) Ajoutez des zones et des propriétés de ressource Java EE annotées @javax.annotation.Resource à vos classes EJB JAX-RS pour accéder facilement aux ressources de votre application. Les injections Java EE ne fonctionnent pas dans des classes Java simples avec des annotations JAX-RS. L'injection de zones et de propriétés de ressource Java EE annotées @javax.annotation.Resource dans vos classes EJB JAX-RS fonctionne uniquement si vos classes annotées JAX-RS sont de type bean enterprise ou bean géré JDCI (Context and Dependency Injection) Java (JSR-299). Par exemple :
    package com.example.jaxrs;
    
    @javax.ejb.Stateless
    @javax.ejb.Local(Purchasable.class)
    public class Book implements Purchasable {
        @javax.annotation.Resource(name="jdcb/TestDataSource")
        private javax.sql.DataSource datasource;
    
        public int getItemsLeft(String itemID) {
            // Reads from the datasource. 
            // Returns the number of items left.  
        }
    
        public Order purchase(String itemID, String orderId) {
            // Reads from the datasource. 
            // Adds the given item to the order id and returns it.  
        }
    }
    Dans cet exemple, si une source de données est correctement configurée avec le nom JNDI approprié, un objet DataSource est injecté dans la classe de ressources.
  5. (Facultatif) Utilisez l'injection @javax.ws.rs.core.Context JAX-RS pour accéder aux informations sur la demande. Vous pouvez ajouter une zone @javax.ws.rs.core.Context UriInfo à votre classe EJB JAX-RS pour accéder aux informations sur l'URI de la demande. Par exemple :
    package com.example.jaxrs;
    
    @javax.ejb.Stateless
    @javax.ejb.Local(Purchasable.class)
    public class Book implements Purchasable {
        @javax.ws.rs.core.Context
        private UriInfo uriInfo;
    
        public int getItemsLeft(String itemID) {
            // Return the number of items left.  
        }
    
        public Order purchase(String itemID, String orderId) {
            // Add the given item to the order id and return it.  
        }
    }
    Pour lire les paramètres de la demande, comme @javax.ws.rs.HeaderParam, @javax.ws.rs.QueryParam et @javax.ws.rs.PathParam, ajoutez un paramètre à votre méthode de ressource. Par exemple :
    package com.example.jaxrs;
    
    @javax.ws.rs.Path("itemsForPurchase/{itemID}")
    public interface Purchasable {
        public int getItemsLeft(String itemID);
    
        @javax.ws.rs.POST
        public Order purchase(
            @javax.ws.rs.PathParam("itemID") String itemID,
            @javax.ws.rs.QueryParam("orderId") String orderID);
    }
    package com.example.jaxrs;
    
    @javax.ejb.Stateless
    @javax.ejb.Local(Purchasable.class)
    public class Book implements Purchasable {
        @javax.ws.rs.core.Context
        private UriInfo uriInfo;
    
        public int getItemsLeft(String itemID) {
            // Returns the number of items left.  
        }
    
        public Order purchase(String itemID, String orderId) {
            // The method parameters contain the request values. 
            // Add the given item to the order id and return it.  
        }
    
        /*  The following field will not be set. */
        @javax.ws.rs.QueryParam("q")
        private String willNotWork;
    
        @javax.ws.rs.QueryParam("q")
        public void setMyQueryParam(String q) {
            /* This property will not be set. */
        }
    }
    Configurations prises en charge Configurations prises en charge: Les annotations de paramètre JAX-RS doivent être ajoutées aux méthodes de ressource dans l'interface métier EJB lorsque vous utilisez des interfaces métier. Elles ne peuvent pas être ajoutées au bean d'implémentation.sptcfg
  6. Conditionnez les beans enterprise dans le répertoire WEB-INF/classes du fichier WAR ou dans un fichier JAR inclus dans le répertoire WEB-INF/lib de votre fichier WAR.

    Lorsqu'un client effectue une demande sur un bean enterprise annoté JAX-RS, l'environnement d'exécution JAX-RS recherche et utilise une instance EJB de la classe pour appeler ensuite la méthode de ressource JAX-RS.

Résultats

Vous avez activé un bean enterprise existant avec des interfaces locales pour exposer les ressources JAX-RS pour consommation.


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=twbs_jaxrs_ejb_localinterface
Nom du fichier : twbs_jaxrs_ejb_localinterface.html