• Save
#5 Java EE5  Client Lourd  et Smart Client
Upcoming SlideShare
Loading in...5
×
 

#5 Java EE5 Client Lourd et Smart Client

on

  • 2,983 views

Attribution: Florent Benoit

Attribution: Florent Benoit

Statistics

Views

Total Views
2,983
Views on SlideShare
2,977
Embed Views
6

Actions

Likes
1
Downloads
0
Comments
0

1 Embed 6

http://www.slideshare.net 6

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

#5 Java EE5  Client Lourd  et Smart Client #5 Java EE5 Client Lourd et Smart Client Presentation Transcript

  • Simplicité de développement avec Java EE 5 et simplification du lancement de clients lourds avec SmartClient JOnAS Day 5.1 [email_address]
  • Agenda
    • Modèle de développement avec Java EE 5
      • Cycle de vie
      • Injection de dépendances
      • Persistance
      • Modèle EJB3
    • Clients lourds : lancement simplifié avec JOnAS 5
  • Cycle de vie
  • Cycle de vie : Introduction
    • Avec Java EE 5, il est facile d'effectuer des actions lors de différentes phases du cycle de vie d'un composant.
      • Après la création de l'instance : @PostConstruct
      • Avant sa destruction : @PreDestroy
    • Aucune interface obligatoire à implémenter pour ajouter des intercepteurs de cycle de vie :
      • Avantage : On supprime le code inutile
        • On a du code uniquement pour la phase du cycle de vie souhaitée
        • Évite d'avoir des « méthodes vides » car requises par l'interface
      • On peut garder le nom des méthodes
  • Cycle de vie : Fichier XML
    • Les intercepteurs de cycle de vie sont définis via des annotations.
    • Ils peuvent également être spécifiés avec les fichiers XML
    <?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?> <ejb-jar xmlns=&quot; http://java.sun.com/xml/ns/javaee &quot; ... version=&quot;3.0&quot;> <enterprise-beans> <session> <ejb-name>MonBean</ejb-name> <ejb-class>monpackage.MonBean</ejb-class> <post-construct> <lifecycle-callback-class>monpackage.MonBean</lifecycle-callback-class> <lifecycle-callback-method> maMethodePostConstruct </lifecycle-callback-method> </post-construct> </session> ...
  • Injection de dépendances
  • Injection de dépendances : Principe
    • Facilite la composition de composants
      • On peut choisir l'objet qui implémente une interface donnée
        • Dans l'exemple suivant, on ne sait pas quelle implémentation sera utilisée, on sait uniquement qu'elle répondra à l'interface demandée
    • IoC : Inversion de contrôle
    • Simplification du code :
      • On supprime tout le code lié à la récupération d'instances d'objets
    @EJB private MonInterface ejb;
    • Récupération d'une connexion vers une BDD
      • Avec J2EE 1.4, l e composant doit récupérer seul sa ressource
    Injection de dépendances : Accès Ressources Context ictx = new InitialContext(); DataSource myDS = null; try { myDS = (DataSource) ictx.lookup(“java:comp/env/jdbc/myDS”); } catch (NamingException e) { ... } Connection connection = myDS.getConnection(); @Resource(name = &quot;jdbc/myDS&quot;,....) private DataSource myDS; private void method() { Connection connection = myDS.getConnection(); }
      • Avec l'injection de dépendances / Java EE 5, l e conteneur injecte la référence
    Demande d'injection
    • Avec J2EE 1.4 :
    • Avec l'injection de dépendance / Java EE 5:
    Context ictx = new InitialContext(); EJBHome ejbHome = null; try { Object o = ictx.lookup(“java:comp/env/ejb/myEJB”); ejbHome = (EJBHome) PortableRemoteObject.narrow(o, EJBHome.class); } catch (NamingException e) { ... } InterfaceEJB ejb = ejbHome.create(); ejb.helloWorld(); @EJB private InterfaceEJB ejb; private void methode() { ejb.helloWorld(); } Injection de dépendances : Accès à un EJB Demande d'injection Plus d'interface Home, l'interface métier est appellée directement
    • L'injection de dépendances peut être réalisée avec l'aide de descripteurs de déploiement XML
    • Exemple d'injection de « env-entry »
    Injection de dépendances : Sans annotations <env-entry> <env-entry-name>monEntree</env-entry-name> <env-entry-type>java.lang.Integer</env-entry-type> <env-entry-value>50</env-entry-value> <injection-target> <injection-target-class>mon.package.MonBean</injection-target-class> <injection-target-name>monEntier</injection-target-name> </injection-target> </env-entry> ... private Integer monEntier; ... Aucune annotation dans le code Valeur 50 injectée
  • Persistance
  • Persistance : JPA, un nouveau modèle
    • Une des critiques sur les « EJB » était liée à son modèle de persistance.
    • Avec Java EE 5, il y a un nouveau modèle de persistance : J ava P ersistence A pi
    • Succède aux beans EJB 2.1 CMP1 et CMP2
        • Les Entités JPA ne sont plus des EJBs
      • Utilisation des annotations : (Approche XDoclet)
      • De concept proche de Hibernate/JDO
        • Modèle P lain O ld J ava O bject
  • Persistance : Gestion des objets
    • Pour accéder aux entités JPA, on passe par un gestionnaire de persistance nommé EntityManager.
    • Un EntityManager est injectable comme d'autres ressources Java EE
    @PersistenceContext private EntityManager entityManager Injection d'un gestionnaire de persistance
  • Persistance : Aperçu du modèle
    • Les entités JPA sont des POJOs
      • Création avec le constructeur « new »
    • La gestion de l'objet entité se fait via l'EntityManager
    • Les requêtes JPA-QL sont exécutées en utilisant l'objet EntityManager
    MonEntity entity = new MonEntity(); entityManager.persist(entity); Query query = entityManager.createNamedQuery(“select b FROM Book b); List<Book> books = query.getResultList();
  • Persistance : Métadonnées Entity @Entity @Table(name=”EMPLOYEES”) @Id public class Employee { private int id; private String name; public int getId() { return id; } public void setId(final int id) { this.id = id; } public void setName(final String name) { this.name = name; } public String getName() { return name; } } Clef primaire
  • Persistance : Les relations
    • Les objets entités JPA peuvent être liés via des relations.
    • Prenons l'exemple de deux objets/classes : Livre et Auteur
    • Nous voyons qu'il peut y avoir une relation entre un livre et un auteur.
      • -> Un livre est écrit par un ou plusieurs auteurs.
    • Pour décrire ces relations, il y a des annotations JPA
      • @OneToOne
      • @ManyToOne
      • @OneToMany
      • @ManyToMany
  • Persistance : Description des informations
    • Les informations liées à la persistance sont stockées dans un fichier nommé « persistence.xml »
    • Ce fichier contient :
      • Les noms des DataSources à utiliser (JTA ou non JTA)
      • Le fournisseur de persistance : Hibernate Entity Manager, EclipseLink, etc.
    • Les paramètres spécifiques pour chaque fournisseur de persistance
      • Dialecte avec la base de données
      • Création ou non des tables/Suppression des données, etc.
    • JOnAS fournit deux implémentations de JPA 1.0
      • Hibernate
      • EclipseLink
    Choix dans le fichier JONAS_BASE/conf/jonas.properties
  • EJB3
  • EJB2 vs EJB3 : Simplicité du développement
    • Les descripteurs de déploiement deviennent optionnels.
      • Utilisation des annotations (métadonnées)
    • Simplification de la persistance.
      • CMP des EJB 2.0 remplacée par JPA (proche du modèle Hibernate/JDO)
    • Un ensemble de valeurs par défaut (TX par défaut Required)
    • Réduction de l'utilisation de certaines exceptions
      • exemple : RemoteException
    • Interface Home (pour le cycle de vie) n'est plus requise
    • Les interfaces « callback » ne sont plus obligatoires. Plus besoin d'implémenter javax.ejb.SessionBean
    • Autorisation de l'héritage
    • Amélioration du langage EJB-QL : requêtes SQL natives
  • Définition de Beans EJB 3.0 [1/2] Interface Implémentation @Stateless throws RemoteException { @Remote public interface HelloWorld { String hello() ; } public class HelloWorldBean implements HelloWorld { public String hello() { return “Hello World !”; } } @Stateful extends Remote { throws RemoteException;
  • @MessageDriven Message Driven Bean Définition de Beans EJB 3.0 [2/2] public class MyMDB implements MessageListener { public void onMessage(Message message) { ... } } @MessageDriven(activateConfig={ @ActivationConfigProperty(propertyName=&quot;destinationType&quot;, propertyValue=&quot;javax.jms.Queue&quot;), @ActivationConfigProperty(propertyName=&quot;destination&quot;, propertyValue=&quot;jms/StockQueue&quot;) } )
  • Transaction Securité @RolesAllowed(“EasyBeans”) @TransactionAttribute(REQUIRES_NEW) Default = REQUIRED Métadonnées EJB 3.0 @Stateless public class MyBean implements MyItf { public void someMethod') { ... } } @Stateless public class MyBean implements MyItf { public void someMethod () {...} }
  • Intercepteurs
    • Intercepte les appels des méthodes métiers
      • Session Beans + Message Driven Beans
      • Peut traiter les exceptions remontées par les méthodes
      • Peut changer les valeurs des paramètres et de retour d'une méthode
    • Intercepteurs
      • Définition en utilisant l'annotation @AroundInvoke
      • Référencés par l'annotation @Interceptors
        • Référence depuis une classe ou une méthode
      • Intercepteurs par défaut (définis dans les descripteurs de déploiement)
      • Possibilité d'exclure certains intercepteurs
        • Intercepteurs par défaut
        • Intercepteurs définis au niveau de la classe
    Interceptors Client InvocationContext Interceptors Client InvocationContext
  • InvocationContext Interface InvocationContext @AroundInvoke Intercepteur de traces public interface InvocationContext { Object getTarget(); Method getMethod(); Object[] getParameters(); setParameters(Object[]); Map getContextData(); // partagé par tous les intercepteurs Object proceed() throws Exception; // appel du prochain intercepteur } public Object trace(InvocationContext invocationContext) throws Exception { long tStart = System.currentTimeMillis(); try { return invocationContext.proceed(); } finally { long elapsed = System.currentTimeMillis() - tStart; System.out.println(inv.getMethod() + &quot; took &quot; + elapsed + &quot; ms.&quot;); } 0
  • Intercepteurs / Notification du cycle de vie
    • Réception de notification lors d'évènements du cycle de vie
    • Définition dans la classe du bean :
    • Ou dans une classe séparée :
    • Même conception que les intercepteurs de méthodes métiers
    public void myPostConstruct(InvocationContext ctx) { ...} @PostConstruct @PreDestroy public void myPreDestroy() { ...}
  • EJB / JPA : Annotations de cycle de vie Annotation SLSB SFSB MDB X X X X X X X X Session & Message Driven Beans Entities @PostPersist @PreRemove @PostRemove @PreUpdate @PostUpdate @PostLoad @PrePassivate (ejbPassivate) @PostActivate (ejbActivate) @PostConstruct (ejbCreate) @PreDestroy (ejbRemove)
  • Migration EJB 2.x / EJB 3.0
    • Objectif : Migrer une application EJB 2.x vers les standards EJB 3.0 en douceur.
    • Contrainte : Autoriser les anciens clients EJB 2.X
      • Client EJB 2.X = Utilisation du Home et de l'opération create() pour obtention d'un bean
  • Définition des interfaces public interface EJB2RemoteHome extends EJBHome { EJB2RemoteInterface create() throws CreateException, RemoteException; } public interface EJB2RemoteInterface extends EJBObject { void hello21Remote() throws RemoteException; }
    • Définition de l'interface « Home » :
    • Définition de l'interface EJB 2.X « Métier » :
    • Définition de l'interface EJB 3.X « Métier » :
    public interface EJB3RemoteBusinessInterface { void hello(); }
  • EJB 3.0 : Création de l'EJB @Stateless @RemoteHome (EJB2RemoteHome. class ) @Remote (EJB3RemoteBusinessInterface. class ) public class EJB2And3Bean implements EJB3RemoteBusinessInterface { /** * Hello world (Interface EJB 3). */ public void hello() { System. out .println( &quot;Hello world EJB 3.0 !&quot; ); } /** * Hello World (Interface EJB 2.1 remote). */ public void hello21Remote() { System. out .println( &quot;Hello world EJB 2.1 Remote!&quot; ); } }
    • Bean EJB 2.x et EJB 3.0
  • Sécurité : Les annotations
    • Avec Java EE 5, la sécurité est désormais configurable à l'aide d'annotations :
      • Package javax.annotation.security
        • @DeclareRoles(String[])
        • @DenyAll
        • @PermitAll
        • @RolesAllowed(String[])
        • @RunAs(String)
  • Agenda
    • Modèle de développement avec Java EE 5
      • Cycle de vie
      • Injection de dépendances
      • Persistance
      • Modèle EJB3
    • Clients lourds : lancement simplifié avec JOnAS 5
  • SmartClient : Lancement facile de clients
    • Problématique :
      • Quels jars faut il ajouter côté client pour le lancement de mon client ?
        • Client.jar : pratique car il contient tout mais souvent trop « gros »
    • La réponse : smart client (JONAS_ROOT/lib/smartclient.jar)
      • L'avantage est que ce jar pèse 30ko
        • Uniquement les classes requises pour le lancement du client sont téléchargées (en moyenne ~ 100 classes)
      • Utilisable en changeant la classe JNDI factory
        • Hashtable<String, Object> env = new Hashtable<String, Object>(); env.put(Context.INITIAL_CONTEXT_FACTORY,' org.ow2.easybeans.component.smartclient.spi.SmartContextFactory' ); InitialContext context = new InitialContext(env);
        • Provider URL = smart://localhost:2503 par défaut
          • Port configurable dans JONAS_BASE/conf/jonas.properties
  •