X-plode - Blog de Mike François » Java EE https://blog.developpez.com/x-plode Tue, 22 Oct 2013 09:39:47 +0000 fr-FR hourly 1 https://wordpress.org/?v=4.1.42 JSF 2.0 avec NetBeans 6.8 et Glassfish v3 https://blog.developpez.com/x-plode/p7968/articles-dvp/jsf_2_0_avec_netbeans_6_8_et_glassfish_v https://blog.developpez.com/x-plode/p7968/articles-dvp/jsf_2_0_avec_netbeans_6_8_et_glassfish_v#comments Thu, 20 Aug 2009 00:25:26 +0000 Bonjour à toutes et à tous,

J’ai réalisé la traduction d’un article anglais de David Salter, auteur du livre Seam 2.x Web Development, qui nous explique l’utilisation de JSF 2 avec Facelets et les Beans.

Lire l’article

Bonne lecture à toutes et à tous.

Et n’hésitez pas à venir réagir sur le forum.

]]> 0 JSF 2.0 : Le brouillon final livré https://blog.developpez.com/x-plode/p7608/java/java-ee/jsf_2_0_le_brouillon_final_enfin_livre https://blog.developpez.com/x-plode/p7608/java/java-ee/jsf_2_0_le_brouillon_final_enfin_livre#comments Sun, 17 May 2009 18:29:44 +0000 Une bonne nouvelle pour tous ceux qui comme moi attendaient désespérément pouvoir lire le brouillon final de JSF 2.0 et d’en connaître ainsi toutes les nouveautés dans les moindres détails.

C’est chose faite, et déjà la communauté Java réalise des webinars pour présenter les nouveautés.
Actuellement, le vote final est en cours jusqu’au 26 Mai.

Une chose certaine, c’est que Java EE fait le plein de nouveautés et nous apporte ainsi un lot considérable d’annotations et de notions qui permettront même aux non-érudits dans la technologie de pouvoir faire leurs armes en toute simplicité.

]]> 0 Servlet 3.0 et la sécurité https://blog.developpez.com/x-plode/p7583/java/java-ee/servlet_3_0_et_la_securite https://blog.developpez.com/x-plode/p7583/java/java-ee/servlet_3_0_et_la_securite#comments Sat, 09 May 2009 14:09:38 +0000 Je viens vous présenter par un article très court, les nouvelles annotations ou l’adaptation de ces dernières aux Servlets 3.0.

En 2.5, les seules déclarations admises étaient @DeclareRoles et @RunAs.
D’un autre côté, @DenyAll, @PermitAll, @RolesAllowed sont seulement supportés par les EJBs.
Dans la spécification des Servlet 3.0, on devrait voir apparaitre @DenyAll, @PermitAll, @RolesAllowed.

@TransportProtected, une nouvelle annotation qui va indiquer si le transport est confidentiel ou non

@DenyAll sera possible au niveau du TYPE.

Les ressources sont peu nombreuses, mais j’ai réussi à obtenir quelques informations de ces annotations.

@DenyAll, @PermitAll, @RolesAllowed, @TransportProtected pourront être appliqué sur :

la classe Servlet, sur l’une ses méthodes :

Bon allez, je vais vous exposer les quelques mises en situation de ces nouvelles notions.

Au niveau du Type :

Au niveau des méthodes :

Tout le monde peut accéder à la méthode GET
Seuls les profils possédant le rôle d’x-plode peuvent accéder à la méthode POST
Et personne ne peut avoir accès à la méthode TRACE

Tout aussi simplement, il nous suffit de rajouter @TransportProtected :

Voilà, rien que 4 lignes supplémentaires, et nous pouvons dire que notre servlet requière le HTTPS, mais que la méthode Get est restreinte aux utilisateurs ayant le rôle de x-plode et qu’elle n’accepte pas de transport HTTPS.

]]> 1 Servlet 3.0, le brouillon final disponible https://blog.developpez.com/x-plode/p7582/java/java-ee/servlet_3_0_le_brouillon_final_disponibl_1 https://blog.developpez.com/x-plode/p7582/java/java-ee/servlet_3_0_le_brouillon_final_disponibl_1#comments Sat, 09 May 2009 09:17:56 +0000 Le très attendu brouillon final de la Servlet 3.0 est disponible sur le site officiel.
Il est à noter que la version sera implémentée dans GlassFish v3 EA.

]]> 0 Servlet 3.0 part 2 https://blog.developpez.com/x-plode/p7577/java/java-ee/servlet_3_0_part_2 https://blog.developpez.com/x-plode/p7577/java/java-ee/servlet_3_0_part_2#comments Thu, 07 May 2009 21:03:50 +0000 Encore une nouveauté (et pas des moindres), les Servlets 3.0 intégreront aussi un panel d’annotations supplémentaires concernant cette fois-ci la sécurité.
Ce qui inclut un prochain article que je rédigerais sur :
@DeclareRoles
@RunAs
@DenyAll
@PermitAll
@RolesAllowed
@TransportProtected

À l’heure actuelle, le brouillon final n’est pas sorti.

Une fois, publier et l’avoir étudié, je vous ferais un résumé de toutes ces nouveautés qui pourraient laisser quelques surprises.

]]> 0 Servlet 3.0 https://blog.developpez.com/x-plode/p7562/java/java-ee/servlet_3_0 https://blog.developpez.com/x-plode/p7562/java/java-ee/servlet_3_0#comments Fri, 01 May 2009 13:03:07 +0000 Une nouveauté qui sera présenté à la JavaOne et dont le brouillon final sera livré d’ici la fin de la semaine.

Des nouveautés qui permettront de facilité le développement.

L’interaction avec le fichier de configuration sera moindre avec l’apparition d’annotations :
@WebServlet
@WebServletContextListener
@ServletFilter
@InitParam

Pour les annotations, je vais vous donner une série d’exemple de code qui vous permettra de comprendre mieux ce que les annotations pourraient apporter et pourquoi, les servlet 3.0 sont une série de nouveautés majeur tel que l’on connu les EJB 3.0.

Pour @WebServlet, il suffit de faire :

 package com.developpez.x-plode.newfeatures
 
import javax.servlet.annotation.InitParam;
import javax.servlet.annotation.WebServlet;
 
@WebServlet(
    name = "SimpleServlet",  
    urlPatterns = {"/simple"},  
    initParams = {
        @InitParam(name = "param1", value = "value1"),
        @InitParam(name = "param2", value = "value2")}
)
public class SimpleServlet {
 
}

Ceci reviendrait à faire :

<servlet>
    <servlet-name>SimpleServlet</servlet-name>
    <servlet-class>com.developpez.x-plode.newfeatures.SimpleServlet</servlet-class>
 
        <init-param>
            <param-name>param1</param-name>
            <param-value>value1</param-value>
        </init-param>
 
        <init-param>
            <param-name>param2</param-name>
            <param-value>value2</param-value>
    </init-param>
 
</servlet>
 
<servlet-mapping>
    <url-pattern>/simple</url-pattern>
    <servlet-name>SimpleServlet</servlet-name>
</servlet-mapping>

Un exemple pour @WebServletContextListener :

package com.developpez.x-plode.newfeatures;
 
import javax.servlet.ServletContextEvent;
import javax.servlet.annotation.WebServletContextListener;
 
@WebServletContextListener()
public class SimpleServletContextListener {
 
    public void contextInitialized(ServletContextEvent event){
    }
 
    public void contextDestroyed(ServletContextEvent event){
    }
}

Ceci reviendrait à faire dans le web.xml :

<web-app>
 
    <listener>
        <listener-class> com.developpez.x-plode.newfeatures.SimpleServletContextListener
    </listener-class>
    </listener>
 
</web-app>

Enfin @ServletFilter,

package com.developpez.x-plode.newfeatures;
 
import javax.servlet.annotation.InitParam;
import javax.servlet.annotation.ServletFilter;
 
@ServletFilter(
    filterName = "SimpleFilter",
    urlPatterns = "/simple",
    initParams =  
        {@InitParam(name = "param1", value = "value1"),
         @InitParam(name = "param2", value = "value2")}
)
public class SimpleFilter {
 
}

Le web.xml,

<filter>
 
    <filter-name>SimpleFilter</filter-name>
    <filter-class> com.developpez.x-plode.newfeatures.SimpleFilter</filter-class>
 
    <init-param>
        <param-name>param1</param-name>
        <param-value>value1</param-value>
    </init-param>
 
    <init-param>
        <param-name>param2</param-name>
        <param-value>value2</param-value>
    </init-param>
 
</filter>
 
<filter-mapping>
    <filter-name>SimpleFilter</filter-name>
    <url-pattern>/simple</url-pattern>
<filter-mapping>

L’intégration des frameworks

Le web.xml tel que nous le connaissons à l’heure actuelle :

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"  
    xmlns="http://java.sun.com/xml/ns/javaee"  
    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/web-app_2_5.xsd">
 
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>/faces/*</url-pattern>
    </servlet-mapping>
 
</web-app>

Le problème, ici, est qu’il n’est pas modulable. Tous la configuration à propos d’une application est inclus dans un fichier unique le web.xml. Le problème qui apparaît est que si nous souhaitons utilisé un ou plusieurs frameworks, il n’y a aucun moyen pour charger la Servlet Container pour l’usage d’un framework spécifique. La seule option que nous pourrions faire, serait d’éditer le descripteur de déploiement.

Pour ce faire, les Servlets 3.0 apportent une nouveauté les web fragments.

Web fragments, web fragments, … Qu’est ce que c’est encore ?

Ok, démonstration d’une déclaration d’un web fragment

<web-fragment>
  <servlet>
    <servlet-name>myservlet</servlet-name>
    <servlet-class>samples.MyServlet</servlet-class>
  </servlet>
  <listener>
    <listener-class>samples.MyListener</listener-class>
  </listener>
</web-fragment>

En fait, un web fragment, peut être considéré comme un web.xml à part entière.

Durant le démarrage de l’application, il est de la responsabilité du Container de scanner les informations trouvées dans le fichier /META-INF/web-fragment.xml.
Enfin, la nouvelle API autorise la déclaration d’une servlet, de classes filtres ou de l’url de mappings de ces dernières.
Par l’exemple :

@ServletContextListener
public class MyListener {
    public void contextInitialized (ServletContextEvent sce) {
       ServletContext sc = sce.getServletContext();
 
       //Declaration d’une servlet et du mappage de servlet
       sc.addServlet("myServlet", "Sample servlet", "samples.MyServlet", null, -1);
       sc.addServletMapping("myServlet", new String[] {"/urlpattern/*"});
 
       //Declaration du filtre et du mappage du filtre
       sc.addFilter("myFilter", "Sample Filter",  " samples.MyFilter", null);
       sc.addFilterMapping("myFilter", new String[] {"/urlpattern/*"}, "myServlet",DispatcherType.REQUEST, false);
    }
}

Les requêtes asynchrones

Voici un petit schéma explicatif :

Et par le code ?

package com.developpez.x-plode.newfeatures;
 
import java.io.IOException;
 
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletRequest;
 
public class SimpleAsyncListener implements AsyncListener{
 
    public void onComplete(AsyncEvent event) throws IOException {
    }
 
    public void onTimeout(AsyncEvent event) throws IOException {
    }
}

On ajoute ainsi le listener à la requête de l’objet :

request.addAsyncListener(new SimpleAsyncListener());

La même chose peut être fait par les annotations Web Servlet et la Servlet Filtre par les attributs asyncSupported et asyncTimout.

package com.developpez.x-plode.newfeatures;
 
import javax.servlet.annotation.InitParam;
import javax.servlet.annotation.WebServlet;
 
@WebServlet(
    name = "SimpleServlet",  
    urlPatterns = {"/simple"},  
    initParams = {
        @InitParam(name = "param1", value = "value1"),
        @InitParam(name = "param2", value = "value2")},
    asyncSupported = true,
    asyncTimeout = 3000
)
public class SimpleServlet {
 
}

Je tiens à remercier Rajiv Mordani ( responsable de la spec JSR 315 ), pour les informations qu’il m’a transmise afin de pouvoir réaliser cet article.

]]> 10 Java EE 6 : les Web Beans et leurs scopes https://blog.developpez.com/x-plode/p7523/java/java-ee/java_ee_6_les_scopes_des_web_beans https://blog.developpez.com/x-plode/p7523/java/java-ee/java_ee_6_les_scopes_des_web_beans#comments Thu, 23 Apr 2009 07:14:29 +0000 À l’heure où l’interaction fastidieuse des couches applicatives touche à l’heure fin, je viens faire la présentation en détail des spécificités de ce nouveau bean.

Dans ce second article à propos des JWB, je vais vous exposer en détail :

Les scopes des Web Beans

Prérequis :

Avant de commencer le sujet, je vais définir les termes nécessaires.

Les scopes sont mappés à un objet context et gérés par le manager Web Bean.

Qu’est ce qu’un objet context ?

Un objet context détermine le cycle de vie et la visibilité des instances de tous les JWB qui possède le même scope.

Que gère le manager Web Bean ?

Il gère :

– La création, la destruction et gère la portée d’un context des Web Beans particulier
– La résolution de portée par type API, type d’annotation binding quand ils sont injectés
– La résolution de portée par type API et annotation
– Resolution de portée par nom ( utilisé dans une expression EL )
– Rappel de cycle de vie et l’injection automatique des autres instances Web Beans
– Interception de méthode, les interceptions de callback, et les decorations
– Les notifications d’évènements

Les scopes des JWB

Bon, rentrons dans le vif du sujet :

Par défaut, les JWB ont 4 scopes :
@RequestScoped
@ApplicationScoped
@SessionScoped
@ConversationScoped

Et 1 pseudo scope :
@Dependent

@RequestScoped :

Le request scope possède un context éphémère, qui est actif seulement pour une action donnée.

De : javax.webbeans.RequestScoped.

Il peut y avoir trois cas:

L’appel à une Servlet :
La requete du scope est actif pendant toute la durée de vie de la méthode service() d’une Servlet dans une application web.
Le context de la requête est détruit à la fin de la requête de la servlet, après le retour de valeur de la méthode service().

L’appel à un service web JEE :
La requete du scope est actif durant l’invocation d’un service web JEE.
Le context de la requete est detruite apres la complete invocation du service web.

L’appel à un EJB :
La requete du scope est actif durant n’importe quelle invocation d’une méthode distante d’un EJB, au cours de tout appel à une méthode EJB timeout et au cours d’un message délivré par n’importe quel EJB Message Driven Bean.
Bien entendu, le context requête est détruit à la fin de toutes ces opérations.

@ApplicationScoped :

L’application scope est identique à celui du scope request à cela prêt qu’il diffère dans la fin du context sur le scope.

De : javax.webbeans.ApplicationScoped

La requete du scope est actif pendant toute la dureté de vie de la méthode service() d’une Servlet dans une application web.

La requete du scope est actif durant l’invocation d’un service web JEE.
Le context de la requete est détruit après la complète invocation du service web.

La requete du scope est actif durant n’importe quelle invocation d’une méthode distante d’un EJB, au cours de tout appel à une méthode EJB timeout et au cours d’un message délivré par n’importe quel EJB Message Driven Bean.

@SessionScoped :

De : javax.webbeans.SessionScoped

Le scope Request est actif pendant toute la duree de vie de la méthode service() d’une Servlet dans une application web.

Le context est partage entre toutes les servlets qui se produisent dans la même session de la servlet HTTP.
Sa destruction est détruite quand le HTTPSession n’est plus valide ou a terminé.

@ConversationScoped :

De : javax.webbeans.ConversationScoped

Chaque JSF possède un scope conversation par défaut. Cependant, nous avons deux cas :

Une requête JSF Faces, auquel cas, nous avons un context actif depuis le commencement jusqu’à se que la réponse soit complétée.

Une requête JSF non Faces, qui a un context actif que durant le rendu de la réponse.

Cette association est gérée par le Web Bean Manager.

Pour information, cette association est effectuée à la restauration de la vue et ne change pas durant la requête.

Une conversation peut avoir deux états.
– Soit transient.
– Soit long-running.
Par défaut, c’est une conversation transient.
Mais nous pouvons détermine la conversation long-running en appelant sa méthode Conversation.begin() et en la terminant par Conversation.end().

Jusque-là, tout est normal. Cependant, je suis sûr qu’une question subsiste dans votre subconscient :

Comment le Web Bean Manager peut gérer les différentes conversations si on en détermine plus d’une,
tout en sachant qu’une conversation est associée à une requête JSF ?

Le principe est simple : un identifiant unique est déterminé (un String).

Tout autant, nous pouvons définir nos propres scopes.
Pour définir un type scope, nous devons :

– Définir une meta-annotation : @ScopeType
– Avoir défini @Target({TYPE,METHOD})
– Et ajouter @Retention(RUNTIME)

@ScopeType
@Target({TYPE, METHOD})
@Retention(RUNTIME)
public @interface XplodeDVPScoped {}

Comme je l’ai dit précédemment, un scope est lien à un objet context. Pour cette raison nous devrons définir le scope via notre manager.

Jusque-là tout va bien. Mais comment faire appel au manager ?

Le manager est une interface:

public interface Manager {
    public Manager addContext(Context context);
    ...    
}

Et nous lui faisons appel par:

manager.addContext(new MethodContext());

Bon ok. Jusqu’ici, la notion est… Abstraite.

Le Web Bean Manager fait tout le temps appel à Manager.getInstance() durant l’instance ou une résolution de nom d’Expression Language.

Ainsi, pour remplir sont rôle, il fait appel à Manager.getContext() pour retrouver les objets context actif associé au scope du JWB.

( Pour information : public Context getContext(Class<? extends Annotation> scopeType); )

Au final, comment déclarer notre scope :

//Par un scope défini par défaut
@RequestScoped
public class ProductList implements DataModel { ... }
 
//Par notre scope défini précédemment
@XplodeDVPScoped
public class Order {
    ...
}

Le pseudo-scope : @Dependent

De : @javax.context.Dependent

Le scope @Dependent est dit pseudo-scope car il diffère de comportement comparé aux autres scopes.

– Aucune instance du bean injecté n’est partage avec les autres points d’injection
– Chaque instance du bean est limité au cycle de vie du bean, servlet ou EJB qui a été injecté.
– Chaque instance du bean qui est utilisé pour évaluer une expression UEL existe uniquement pendant la durée de l’évaluation
– Chaque instance du bean qui recoit une methode producer, un champ producer, une methode dsposal ou l’appel d’une méthode observer dure uniquement pendant la durée de l’invocation.

Mes prochains articles sur les Web Beans porteront sur : les types de binding, les types de déploiement, les Names Web Bean, les stéréotypes…

]]> 0 Java EE 6 : Introduction aux Web Beans https://blog.developpez.com/x-plode/p7487/java/java-ee/java_ee_6_introduction_aux_web_beans https://blog.developpez.com/x-plode/p7487/java/java-ee/java_ee_6_introduction_aux_web_beans#comments Tue, 14 Apr 2009 16:11:03 +0000 Java EE 6

Une nouveauté annoncée ( et pas des moindres) dans Java EE 6 : les Web Beans.

Les Web Beans

De nos jours, les EJBs 3.0 ont apporté une nouvelle notion de simplicité et d’évolution dans la programmation des modèles EJB.
Dès lors, peut-on imaginer JEE sans ses EJBs ?

Malgré les évolutions, les EJBs 3.0 ne résolvent pas le problème d’interopérabilité
entre la couche de présentation et la couche de persistance des données.

C’est pourquoi Sun s’est orienté sur des frameworks
qui connaissent un succès grandissant ( ça rappel … Hibernate ).
Ainsi, google guice et JBoss Seam ont été, une source d’inspiration importante
amenant Sun a créé un nouveau bean nommé : Java Web Beans.


Les Java Web Beans kesako ?

Un java Web Bean peut être une classe Java, un EJB session ou une classe bean singleton,
une méthode producer ou une queue ou un topic JMS.

Les autres attributs d’un Java Web Bean sont soit:

Déclare explicitement dans l’implémentation de la classe,
Déclare explicitement dans web-beans.xml
Ou par défaut dans le Web Bean manager.

Attention, si le Web Bean est un EJB session, il aura une vue locale.

Au final, à quoi sert un Java Web Bean?

Les Web Beans représentent l’unification de deux composants JEE : les EJB 3 et Les Managed Beans de JSF.
Le but des JWB :

Proposer un modèle de programmation à état ou contextuel compatible avec les EJBs et les managed beans.
Proposer un modèle extensible.
Pouvoir bénéficier de lookups (JNDI), de DI (Injection de Dépendances) et de résolution via EL.
Un modèle conversationnel pour le web.
Bénéficier d’interceptors (sous partie d’AOP)
proposer un modèle événementiel.
Permettre leur intégration avec JSF, JPA et les Servlets.
permettre leur intégration avec la notion de profiles du futur Java EE 6

Techniquement, qu’est-ce qu’un Java Web Bean ?

Un Java Web Bean :

C’est une classe concrète, ou annotée @Decorator
C’est une classe avec un constructeur sans argument, ou bien,
C’est une classe avec un constructeur annoté @Initializer

Mais attention, un Java Web Bean ne peut pas être :

Un type paramétré
Une classe interne non static
Une classe annotée avec les annotations @Entity ou les annotations des EJBs
Une classe qui implémente :
Javax.servlet.Servlet
Javax.servlet.Filter
Javax.servlet.ServletContextListener
Javax.servlet.HttpSessionListener
Javax.servlet.ServletRequestListener
Javax.ejb.EnterpriseBean
Une classe qui hérite de javax.faces.component.UIComponent
Un EJB déclare dans ejb-jar.xml
Une entité JPA déclare dans orm.xml

Une classe qui respecte ceci est un simple Web Bean.
Les éléments additionnels peuvent être définis dans un document XML, le web-beans.xml.

Que peut nous apporter techniquement un Java Web Bean ?

Rien ne vaut des exemples pour comprendre l’une des choses les plus innovantes.

Voici un simple Java Web Bean :

public class Hello {  <br />
 <br />
 public String hello(String name){  <br />
 <br />
 <br />
 return "Hello "+name;  <br />
 <br />
 }  <br />
}

Ici, on peut voir qu’un JWB bénéficie d’une DI (Injection de Dépendances) et
à son membre hello automatiquement injecté par le conteneur, grâce à l’annotation @Current.

public class Printer {  <br />
 <br />
 @Current Hello hello;  <br />
 <br />
 public void print(String name){  <br />
 <br />
System.out.println(hello.hello("World"));  <br />
 <br />
 }  <br />
}

Un autre exemple ?

Une fois défini, un WebBean peut être nommé pour pouvoir y accéder depuis l’EL par exemple:

@Named("products")  <br />
public class ProductList implements DataModel { ... }

Notez l’annotation @Named pour spécifier le nom.

<h:outputText value="#{products.total}"/>

Si le web beans est déclaré dans le web-bean.xml, on peut spécifier le Web Bean name ainsi :

<myapp:ProductList> <br />
    <Named>products</Named> <br />
</myapp:ProductList>

Voici une brève présentation des web beans qui apparaîtront dans JEE 6.

Les prochains articles seront dédiés à chaque spécificité des Web Beans et les autres nouveautés de JEE 6.

]]> 2