Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision		 Révision précédente
enseignement:d35:tp:ejb [2021/11/26 15:01] – Emmanuel Brunoenseignement:d35:tp:ejb [2023/09/20 18:52] (Version actuelle) – modification externe 127.0.0.1
Ligne 1: Ligne 1:
-====== D35 - TP3 - EJB et REST ====== +====== I311 - EJB, CDI et REST ====== 
-L'objectif de cette séance est de mettre en place simplement des EJB en lien avec les services web REST et la persistance JPA.+L'objectif de cette séance est de mettre en place simplement des EJB, des beans CDI en lien avec les services web REST et la persistance JPA dans un serveur d'application géré dans un conteneur.
  
 ===== Mise en place de l'environnement de travail ===== ===== Mise en place de l'environnement de travail =====
-Dans ce cadre de ces TP nous utiliserons le serveur d'applications JEE glassfish.+==== Le serveur d'application JEE ==== 
 +Dans le cadre de ces TP nous utiliserons le serveur d'applications JakartaEE Glassfish et plus précisément la distribution Payara (https://www.payara.fish/). Dans un premier temps, nous utiliserons la version 5 complète  (https://hub.docker.com/r/payara/server-full). La série des Payara5 est compatible avec Jakarta EE9.1 et la série Payara6 avec Jakarta EE 10. Des images docker sont disponibles pour différents profils et différents JDK (https://hub.docker.com/u/payara/). 
  
-==== Manuellement ==== +Une édition spéciale de payara dite micro (https://www.payara.fish/learn/getting-started-with-payara-micro/) est dédiée aux architectures micro-services.
-<note tip> +
-Mettez en place votre propre serveur glassfish en suivant  http://bruno.lsis.univ-tln.fr/java/glassfish +
-ou directement avec docker (cf. ci dessous). Pour installer Docker dans un VM suivez https://bruno.lsis.univ-tln.fr/docker/dockerinvm +
-</note>+
  
-==== Avec docker ==== +==== Installation dans des conteneurs ==== 
-Il est aussi possible d'utiliser docker pour cela. +Il fortement conseillé d'utiliser des conteneurs pour mettre en oeuvre le serveur d'application, la base de données relationnelles et les autres services. 
-https://github.com/emmanuelbruno/dockerpayaracompose + 
-(qui s'appuie sur https://github.com/payara/docker-payaraserver-full)+Vous trouverez ici un exemple de base qui s'appuie sur https://github.com/payara/docker-payaraserver-full : 
 +https://github.com/dptinfoutln/dockerpayaracompose/tree/develop
  
-Installer glassfish et la base de donnée (postgres) : 
 <konsole> <konsole>
 <nowiki> <nowiki>
   git clone git@github.com:dptinfoutln/dockerpayaracompose.git   git clone git@github.com:dptinfoutln/dockerpayaracompose.git
   cd dockerpayaracompose   cd dockerpayaracompose
-  docker-compose build --build-arg http_proxy=$http_proxy --build-arg https_proxy=$http_proxy payara-full +  docker-compose up -d  
-  docker-compose up -d payara-full +
   docker-compose  logs -f    docker-compose  logs -f 
 </nowiki> </nowiki>
 </konsole> </konsole>
  
-L'interface du serveur est accessible sur https://localhost:4848/ ou celle de votre VM virtualbox.+L'interface d'administration du serveur est accessible sur https://localhost:4848/ (ou l'IP de votre VM).
  
-Paramétrer les connexions à la base de données : +Pour paramétrer les connexions à la base de données, étudier le docker-compose.yml qui contient un exemple avec H2 (à adapter pour postgres).
-<konsole> +
-<nowiki> +
-docker-compose exec payara-full /opt/payara41/bin/asadmin \ +
-    --user admin \ +
-    --passwordfile=/opt/pwdfile \ +
-    create-jdbc-connection-pool \ +
-      --datasourceclassname org.postgresql.ds.PGConnectionPoolDataSource \ +
-      --restype javax.sql.ConnectionPoolDataSource \ +
-      --property portNumber=5432:password=glassfishdbpassword:user=glassfish:serverName=db:databaseName=glassfish \ +
-      postgres-pool +
-</nowiki> +
-</konsole>+
  
-<konsole> +Pour déployer une application, il est possible de le faire depuis l'interface web d'administration, via un volume docker, ou en faisant une image contenant l'application. Votre IDE peut être paramétré pour faire cela via l'API spécifique du serveur (https://docs.payara.fish/community/docs/documentation/ecosystem/intellij-plugin/README.html).
-<nowiki> +
- docker-compose exec payara-full /opt/payara41/bin/asadmin \ +
-    --user admin \ +
-    --passwordfile=/opt/pwdfile \ +
-    create-jdbc-resource \ +
-      --connectionpoolid postgres-pool \ +
-      jdbc/postgres-pool +
-</nowiki> +
-</konsole> +
- +
-Déployer une application (après compilation ci dessous), soit par l'interface web soit si les volumes docker sont utilisables, soit  +
-  cp /tmp/ejb/target/ejb-1.0-SNAPSHOT.jar data/payara  +
- +
-<del>===== Services Web REST ===== +
-Pour des rappels sur REST vous pourrez lire ou relire une introduction à [[http://fr.slideshare.net/MathieuHicauber/services-rest-jersey-39190011|Rest et Jersey]] et  [[enseignement:d24:tp:rest|tp de d24 sur Rest]]. +
- +
-Les EJB peuvent être utilisés très simplement dans des services web, il suffit de les annoter comme des ressources. +
- +
-L'archetype suivant présente un exemple : +
-<konsole> +
-<nowiki> +
-mvn archetype:generate \ +
- -DarchetypeGroupId=com.sun.jersey.archetypes  \ +
- -DarchetypeArtifactId=jersey-quickstart-ejb \ +
- -DarchetypeVersion=1.19 \ +
- -DgroupId=fr.univtln.bruno.test \ +
- -DartifactId=ejbws \ +
- -Dversion=1.0-SNAPSHOT +
-mvn package +
-</nowiki> +
-</konsole> +
-Il faut ensuite le compiler, en faire un package (war) et le déployer sur un serveur JEE. +
- +
-<konsole> +
-<nowiki> +
-/t/ejbws$ asadmin start-domain domain1 +
-Picked up _JAVA_OPTIONS: -Djava.net.preferIPv4Stack=true +
-Waiting for domain1 to start .......... +
-Successfully started the domain : domain1 +
-domain  Location: /home/bruno/glassfish4/glassfish/domains/domain1 +
-Log File: /home/bruno/glassfish4/glassfish/domains/domain1/logs/server.log +
-Admin Port: 4848 +
-Command start-domain executed successfully. +
-/t/ejbws$ asadmin deploy target/ejbws.war +
-</nowiki> +
-</konsole> +
- +
-Le serveur web associé est accessible ici (cf. ''src/main/webapp/index.jsp'', les jsp seront abordées plus tard) :  +
-http://localhost:8080/ejbws/ +
- +
-Ainsi que les service web associés au resources : +
-   +
-  curl http://localhost:8080/ejbws/webresources/myresource +
- +
-<note> +
-Etudier en détail cet exemple avant de passer à la suite.  +
-</note> +
- +
-</del> +
- +
-Utiliser l'application de départ proposée ici : https://www.eclipse.org/community/eclipse_newsletter/2019/november/1.php +
- +
-en résumé  +
- +
-<konsole> +
-<nowiki> +
-mvn archetype:generate \ +
-  -DarchetypeGroupId=de.rieckpil.archetypes \ +
-  -DarchetypeArtifactId=jakartaee8 \ +
-  -DarchetypeVersion=1.0.0 \ +
-  -DgroupId=de.rieckpil.blog \ +
-  -DartifactId=jakartaee-8-project \ +
-  -DinteractiveMode=false +
-</nowiki> +
-</konsole> +
- +
-<konsole> +
-<nowiki> +
-mvn package +
-</nowiki> +
-</konsole> +
- +
-déployer le .war qui se trouve dans le /target dans payara +
- +
-accéder à la resource +
- +
-<konsole> +
-<nowiki> +
-curl http://localhost:8080/jakartaee-8-project/resources/sample'' +
-</nowiki> +
-</konsole> +
- +
-===== Hello EJBs ===== +
-En utilisant l'archetype Maven suivant, nous allons mettre en place un "Hello word REST à base d'EJB." +
- +
-<konsole> +
-<nowiki> +
-mvn archetype:generate \ +
- -DarchetypeGroupId=org.codehaus.mojo.archetypes  \ +
- -DarchetypeArtifactId=ejb-javaee7 \ +
- -DarchetypeVersion=1.1 \ +
- -DgroupId=fr.univtln.bruno.test \ +
- -DartifactId=ejb \ +
- -Dversion=1.0-SNAPSHOT +
-</nowiki> +
-</konsole>+
  
-<note> +===== Une application JEE "Minimale" ===== 
-Ajouter à la classe ''NewSessionBean'' une variable message de type String ("Hello World from EJB !") et son accesseur. +  * Nous allons revoir les concepts de bases et la mise en pratique avec une application minimale : 
-</note>+    * https://github.com/ebpro/simplejee91/tree/develop
  
-<note> +  Ce projet illustre les concepts et techniques de base en s'appuyant sur les documents suivants.
-Annoter l'EJB ''NewSessionBean'' pour en faire une ressource Web Service Rest (puis ''mvn install''). Ajouter le projet EJB comme une dépendance du service web précédent ce qui ajoutera les ejb au fichier war final. Redéployer le projet et tester les services. +
-</note>+
  
-<note warning> +  * La mise en place de base et l'utilisation d'une Servlet sont expliqués ici : 
-La plupart des librairie sont déjà présente dans le serveur d'application, il faut donc faire attention au scope maven des dépendances.  +    * https://blog.payara.fish/getting-started-with-jakarta-ee-9-hello-world 
-</note>+    * L'accès à la servlet http://localhost:8080/hello/world
  
-===== JPA dans JavaEE ===== +  * La mise en place de base d'une API REST est présentée ici : 
-Pour utiliser JPA avec un serveur JEE, le ''persistence.xml'' doit être adapté : +    * https://blog.payara.fish/getting-started-with-jakarta-ee-9-how-to-create-a-rest-api-with-jakarta-ee-9 
-<code xml> +    * L'accès à l'API REST : curl -v http://localhost:8080/hello/api/hello
-<?xml version="1.0" encoding="UTF-8"?> +
-<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" +
-             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" +
-             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence +
-             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd" +
-             version="2.1">                   +
-    <persistence-unit name="authors" transaction-type="JTA"> +
-        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider> +
-        <jta-data-source>jdbc/h2-pool</jta-data-source> +
-                //classes..  +
-    </persistence-unit> +
-     +
-</persistence> +
-</code>+
  
-Ensuite l'entity manager est injecté avec ''@PersistenceContext'' ou en précisant éventuellement l'unité de persistance''@PersistenceContext(unitName = "....")''. Cf. https://docs.oracle.com/javaee/7/tutorial/persistence-intro003.htm#BNBQW+  * La mise en place de base de CDI est présentée ici  
 +    * https://blog.payara.fish/getting-started-with-jakarta-ee-9-context-and-dependency-injection-cdi 
 +    * curl -v "http://localhost:8080/hello/api/hello/cdi/Bob?language=fr" 
 +    * curl -v "http://localhost:8080/hello/api/hello/bye"
  
-<note tip>Glassfish est fourni et préparamétré pour une base de donnée relationnelle appelée Derby. Elle se lance avec la commande ''asadmin start-database''.</note>+  * A vous de découvrir la mise en place JPA avec JEE (deux points principaux : l'adaptation du persistance.xml et l'injection d'un entity manager). 
 +    * https://blog.payara.fish/getting-started-with-jakarta-ee-9-jakarta-persistence-api-jpa
  
-Vous trouverez plus de détails sur les EJB dans le tutoriel JEE : https://docs.oracle.com/javaee/7/tutorial/partentbeans.htm#BNBLR+A partir de là, mettre en place vos classes métiers avec CDI et des EJBs en vous appuyant sur la persistance JPA et permettre l'accès via une API REST.
  
-<note> 
-Mettez en place (par deux) une API REST avec JEE pour gérer un programme gestion de données. Vous pourrez le faire sur votre TP de révision ou directement sur le  ([[enseignement:d35:tp:tp6|mini projet qui servira d'évaluation pratique]]). [[http://www.vinaysahni.com/best-practices-for-a-pragmatic-restful-api|Best Practices for Designing a Pragmatic RESTful API]] de Vinay Sahni.  
-</note> 
  
-Voilà un exemple https://github.com/emmanuelbruno/simplejee/tree/development+Pour aller beaucoup plus loin.... https://github.com/hantsy/jakartaee9-starter-boilerplate
  
 ---- struct data ---- ---- struct data ----