Débuter avec ejb
Configuration d’EJB avec JBoss AS 7.1
1. Aperçu
Dans cet article, nous allons discuter de la façon de démarrer avec Enterprise JavaBeans (EJB). Nous utiliserons JBoss AS 7.1.1.Final, mais vous êtes libre d’utiliser n’importe quel serveur de votre choix.
2. Dépendances Maven pour Bean
Pour utiliser EJB, assurez-vous d’en ajouter la dernière version à la section des dépendances de votre fichier pom.xml :
<dependency>
<groupId>org.jboss.spec.javax.ejb</groupId>
<artifactId>jboss-ejb-api_3.2_spec</artifactId>
<version>1.0.0.Final</version>
</dependency>
Assurez-vous d’ajouter correctement les dépendances JBoss car nous utiliserons JBoss comme serveur d’applications dans ce didacticiel. Dans la dernière partie du didacticiel, nous discuterons en détail de la configuration de la construction maven pour le projet.
3. Télécommande EJB
Commençons par créer l’interface Bean appelée HelloWorldRemote.
public interface HelloWorldRemote {
public String getHelloWorld();
}
Nous allons maintenant implémenter l’interface ci-dessus et la nommer “HelloWorldBean”.
@Stateless
public class HelloWorldBean implements HelloWorldRemote {
public HelloWorldBean() {
}
@Override
public String getHelloWorld(){
return ("Hello World");
}
}
Notez la notation @Stateless en haut de la déclaration de classe. Il désigne un bean session sans état.
**4. Configuration Maven pour Remote Bean **
Dans cette section, nous verrons comment configurer maven pour construire et exécuter l’application sur le serveur.
Regardons les plugins un par un.
4.1. Plugin du compilateur
Le maven-compiler-plugin est utilisé pour compiler les sources de notre projet.
Ici, nous avons utilisé la version 2.3.1 du plugin avec le JDK source et cible défini sur 1.7 sous configuration.
Nous avons défini ces paramètres en tant que propriétés dans la balise
<version.compiler.plugin>2.3.1</version.compiler.plugin>
<!-- maven-compiler-plugin -->
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>
4.2 Le plugin EJB
Ce plugin génère un fichier Bean ainsi que le jar client associé.
Nous avons spécifié la version ejb en tant que 3.2 et la propriété generateClient est définie sur true, ce qui génère le client.
4.3 Déploiement dans JBoss
Le plug-in jboss-as-maven est utilisé pour déployer, redéployer, annuler le déploiement ou exécuter l’application dans JBoss AS 7.
Dans cette configuration, nous spécifions le même nom de fichier de construction que le nom de fichier de construction du projet qui est par défaut de la forme id-artefact-version dans notre cas ejb-remote-1.0-SNAPSHOT.
4.4 Dépendances Maven requises pour les EJB
jboss-javaee-6.0 définit la version des API Java EE 6 de JBoss que nous voulons utiliser.
JBoss distribue un ensemble complet d’API Java EE 6, y compris une nomenclature (BOM).
Une nomenclature spécifie les versions d’une pile (ou d’une collection) d’artefacts. Nous le spécifions dans la balise
<dependency>
<groupId>org.jboss.spec</groupId>
<artifactId>jboss-javaee-6.0</artifactId>
<version>${version.org.jboss.spec.jboss.javaee.6.0}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
4.5 Annotations
Les éléments suivants obtiendront la dépendance des annotations :
<dependency>
<groupId>org.jboss.spec.javax.annotation</groupId>
<artifactId>jboss-annotations-api_1.1_spec</artifactId>
<scope>provided</scope>
</dependency>
4.6 EJB version 3.2
Dans le morceau de code suivant, nous obtenons la dernière version des spécifications :
<dependency>
<groupId>org.jboss.spec.javax.ejb</groupId>
<artifactId>jboss-ejb-api_3.2_spec</artifactId>
<version>1.0.0.Final</version>
</dependency>
Pour exécuter le projet ci-dessus dans un serveur JBoss, nous devons d’abord exécuter :
mvn clean install
Ensuite, nous devons le déployer sur un serveur JBoss en cours d’exécution en exécutant la commande maven suivante :
jboss-as:deploy
Vous devriez maintenant voir le fichier jar en cours de déploiement sur le serveur jboss.
Vous pouvez également copier le fichier jar disponible à partir du dossier cible dans le projet et le coller dans le dossier webapp du serveur.
5. Mise en place du Projet Client
Après avoir créé le bean distant, nous devons tester le bean déployé en créant un client.
Discutons d’abord de la configuration maven pour le projet.
5.1 Plugins Maven utilisés
Le maven-compiler-plugin est utilisé pour compiler les sources de votre projet.
Nous avons spécifié la version 1.7 de jdk pour les classes source et cible.
Notre client est un programme Java, pour l’exécuter nous utilisons le exec-maven-plugin qui aide à exécuter les programmes système et Java. Nous devons spécifier l’exécutable (c’est-à-dire java), le chemin de classe et la classe java (com.baeldung.ejb.client.Client).
Le chemin de classe est laissé vide car le plug-in inclut les arguments de chemin de classe nécessaires en fonction des dépendances fournies.
5.2 Dépendances Maven pour le client EJB3
Pour exécuter le client EJB3, nous devons inclure les dépendances suivantes.
Nous dépendons des interfaces métier distantes EJB de cette application pour exécuter le client. Nous devons donc spécifier la dépendance jar du client ejb. La balise
<dependency>
<groupId>com.theopentutorials.ejb3</groupId>
<artifactId>ejbmavendemo</artifactId>
<type>ejb-client</type>
<version>${project.version}</version>
</dependency>
Les dépendances jboss-transaction-api_1.1_spec, jboss-ejb-api_3.1_spec, jboss-ejb-client, xnio-api, xnio-nio, jboss-remoting, jboss -sasl, jboss-marshalling-river ont une portée en tant qu’exécution car ils sont requis au moment de l’exécution et non au moment de la compilation.
Les dépendances jboss-javaee-6.0 et jboss-as-ejb-client-bom sous dependencyManagement ont une portée d’importation. Ceci est utilisé pour inclure les informations de gestion des dépendances d’un POM distant dans le projet en cours. Ces POM distants sont fournis par JBoss qui contient les dépendances nécessaires à l’exécution du client.
5.3 Propriétés du client JBoss EJB
Créez un fichier sous « src/main/resources » et nommez-le jboss-ejb-client.properties.
remote.connectionprovider.create.options.org.xnio.Options.SSL_ENABLED=false
remote.connections=default
remote.connection.default.host=localhost
remote.connection.default.port = 4447
remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false
6. Création de la classe client
Nous créons d’abord une classe ClientUtility :
public class ClientUtility {
private static Context initialContext;
private static final String PKG_INTERFACES = "org.jboss.ejb.client.naming";
public static Context getInitialContext() throws NamingException {
if (initialContext == null) {
Properties properties = new Properties();
properties.put(Context.URL_PKG_PREFIXES, PKG_INTERFACES);
initialContext = new InitialContext(properties);
}
return initialContext;
}
}
Créons maintenant la classe Client réelle qui consommera le bean que nous avons déployé sur le serveur :
public class Client {
//The lookup method to get the EJB name
private static HelloWorldRemote doLookup() {
Context context = null;
HelloWorldRemote bean = null;
try {
// 1. Obtaining Context
context = ClientUtility.getInitialContext();
// 2. Generate JNDI Lookup name
String lookupName = getLookupName();
// 3. Lookup and cast
bean = (HelloWorldRemote) context.lookup(lookupName);
} catch (NamingException e) {
e.printStackTrace();
}
return bean;
}
private static String getLookupName() {
// The app name is the EAR name of the deployed EJB without .ear suffix.
// Since we haven't deployed the application as a .ear, the app name for
// us will be an empty string
String appName = "";
// The module name is the JAR name of the deployed EJB without the .jar
// suffix.
String moduleName = "ejb-remote-0.0.1-SNAPSHOT";
// AS7 allows each deployment to have an (optional) distinct name. This
// can be an empty string if distinct name is not specified.
String distinctName = "";
// The EJB bean implementation class name
String beanName = "HelloWorldBean";
// Fully qualified remote interface name
final String interfaceName = "com.baeldung.ejb.tutorial.HelloWorldRemote";
// Create a look up string name
String name = "ejb:" + appName + "/" + moduleName + "/" + distinctName
+ "/" + beanName + "!" + interfaceName;
return name;
}
}
La classe Client consomme le bean et affiche le résultat.
sept. Conclusion
Nous avons donc créé un serveur EJB et un client qui consomme le service. Le projet peut être exécuté sur n’importe quel serveur d’application.