J’avais déjà fait une vidéo sur la création d’un pool de connexion MySQL sur Glassfish. Malheureusement, lors de la pratique en test réel avec une application web et des alpha-testeurs, plus rien ne fonctionnait au bout de quelques heures : « Impossible to resize Pool » x 500 dans mes logs.

Créer plus de Connexions possibles n’a pas servi à grand chose (j’ai testé avec 256 au lieu de 16 :)) ). Par contre j’ai voulu pingé le pool grâce à l’interface de Glassfish. Lorsqu’aucune application n’est déployé, le pool ne ping pas puisque le .jar de Mysql n’est pas installé par défaut.

J’ai donc :

• Copié mon Mysql Connector/J dans /usr/share/glassfish/lib
• Précisé le .jar dans le Classpath de la JVM du serveur
• Ajouté tant qu’à faire de la mémoire : c’est un serveur java !

D’une part je ping, et de plus je peux maintenant bombarder mon serveur de requêtes. J’en déduis peut-être à tort qu’utiliser le mysql.jar dans le /lib de son .war ne tient pas très bien la route.

Le serveur encaisse bien son millier de requêtes, et pour l’instant, je n’ai pas d’avertissements d’OVH .

Voici deux vidéos-tutoriels permettant de fabriquer des composants Javabeans de façon simple, rapide et avec du code propre grâce à Netbeans

– I) Beans Binding : Synchroniser la valeurs d’une propriété avec celle d’un formulaire
– II) Programmation par Events : Réduire les combinaisons if/else avec une programmation modulaire, pilotée par les Events customizés.

Deux vidéos devraient arriver après les fêtes. Les articles pour Dev.com…. en avril

Mais il y a dans le Domaine d’une école, des cas plus complexes que récupérer les informations d’un utilisateur. Par exemple récupérer l’ensemble des élèves du cours 24. On utilisera la requête :
GET /wsedupassion/course/24/students

Pour connaitre le professeur de ce groupe, ce sera :
GET /wsedupassion/course/24/teacher

Pour ajouter l’étudiant 18 à ce cours:
PUT /wsedupassion/course/24/students?idstudent=18

Et pour tout connaitre de ce cours :
GET /wsedupassion/course/24/

Et pour traiter ces requête, on utilisera les pages jsp :
– /wsedupassion/service/course/course.jsp
– /wsedupassion/service/course/teacher.jsp
– /wsedupassion/service/course/students.jsp
Le serveur (Apache, Glassfish, JBOSS, …) doit donc analyser très correctement l’uri pour dispatcher vers la bonne JSP. Voici un petit tutoriel pour les bases.

En première intention, j’avais prévu :

Mais les expressions régulières ne sont en fait absolument pas reconnues. Le serveur ne connnait que ‘*’ et privilégie le pattern selon 4 règles hierarchiques from outer space :
– Il préfère le pattern exact :/wsedupassion/account plutot que /wsedupassion/*
– Il préfère le pattern le plus long : /course/12/teacher/ plutot /course/*
– Il préfère les xyz/* (chemin) plutôt que *.xzy (type de fichier)
– Il choisit / si cette servlet racine existe

Et sinon le serveur envoit l’erreur 404( Source).

Mon fichier web.xml ressemblera donc à :

De quoi faire hurler tout prof de fac tatillon sur ses expressions régulières. Mais c’est à priori suffisant pour fonctionner, et en plus intuitif. Que demande le peuple ? Apparemment plus, puisque ca ne fonctionne pas. Deux ‘*’, ca fait beaucoup.
/school/*/student/ n’est pas différencié de /school/*/teacher et renvoient d’ailleurs toutes les deux une erreur 4004 !

Pour dispatcher des uri un peu sophistiquées, il faudrait donc
– un servlet-mapping vers un dispatcher
– le dispatcher analyse l’uri
– on forward la requete vers une autre servlet

Je n’aime pas du tout ce mélange des genres : le servlet mapping a pour objet de rediriger, et devoir faire à la main une redirection dans le processus de redirection via des classes barbares comme un RequestDispatcher. Beurk ! Quelqu’un a mieux ?

Sinon, autant garder l’uri de la JSP. Et tant pis pour les dogmes !

<form action ="script.php" >

<input type="radio" name="radioGroup" id="radio" value="LEAVE_IT" />Leave It
<input type="radio" name="radioGroup" id="radio2" value="TAKE_IT" /> Take It
<input type="button" value="OK" />

</form>

Cette astuce du jour a pour but de récupérer le bouton radio en Javascript, avec la bibliothèque Prototype, sans script php, ni même la balise form.

En Ajax, on veut éviter le plus souvent possible l’action sur les balises FORM. Même si l’action est nulle : <form action ="" >, alors le navigateur affiche une nouvelle url : http://mypage?Submit=OK, par exemple. On peut utiliser un bouton de type « button » ou « submit » utilisant l’attribut onclick= »doIt(); »

La fonction javascript doIt() pourra alors récupérer la valeur du bouton radio avec cette fonction qui ne nécessite que l’attribut name du groupe de boutons radio :

/**
* Returns the value of the selected radio button in the radio group
* returns "" if the radio is not found or if nothing is checked
* Public Domain
*/
function $RF(radioName){
    array=$$('input');
    var value="";
     
    array.each(
          function (radio){
               if (radio.hasAttribute("name") && radio.readAttribute("name")==radioName)
                  if (radio.checked=="true" || radio.checked) value=radio.getValue();  
         }
   );//End of each()
   return value;  
}

Le nom de la fonction est dans le plus (im)pur style Prototype, RF signifiant RadioForm.
On l’utilisera ainsi :

function doIt(){
  alert($RF("radioGroup"));
}

Edupassion.com fournira un éditeur de cours online spécialement concu pour les besoins d’un prof. Avec notamment une numérotation des paragraphes de type GrandX, PetitX, et Lettre.
Le but du jeu est donc de traduire la balise XML <paragraph depth="GrandX" number="II">value</paragraph > en <h2>II) value</h2> pour le XHTML, ou <paragraph depth="Lettre" number="c">value</paragraph> en <h4>c)value</h4>

XSLT a pour objectif de transformer le Modèle (fichier XML) en Vue (fichier XHTML), et il eut été logique qu’XSLT transformasse aussi les nombres des paragraphes en caractères adaptés comme "II", ou "c". Cette opération purement fonctionnelle est cependant plus simple et surtout plus propre à la relecture en utilisant Java.

Pour résoudre le problème, la première idée qui vient à l’esprit est de le traiter cas par cas :

<xsl:template match="paragraph">
<xsl:choose>
<xsl:when test="./@depth=’GrandX’ ">
<h2>
<xsl:value-of select"./@number"/>)<xsl:value-of select"."/>
</h2>
</xsl:when>

<xsl:when test="./@depth=’PetitX’ ">
<h2>
<xsl:value-of select"./@number"/>)<xsl:value-of select"."/>
</h2>
</xsl:when>

<xsl:when test="./@depth=’Lettre’ ">
<h2>
<xsl:value-of select"./@number"/>)<xsl:value-of select"."/>
</h2>
</xsl:when>

</xsl:choose>
</xsl:template>

Ca marche, mais dès que la programmation sera plus complexe (séparation entre le titre et le corps du paragraphe, ou boutons de controle), alors le corps de chaque choix se remplira, ce qui n’est pas bien beau. On pourra utiliser <xsl:apply-templates/>, mais là encore, l’imbrication multiples de ces balises n’est pas conseillée si ce code doit être lu par des collègues non expert en XSLT.

Comme la balise choisie est variable, nous allons tout logiquement utiliser une variable, et créer un element dynamiquement.

<xsl:template match="paragraph">

<xsl:variable name="baliseVar">
<xsl:choose>

<xsl:when test="./@depth=’GrandX’ ">h2</xsl:when>
<xsl:when test="./@depth=’PetitX’ ">h3</xsl:when>
<xsl:when test="./@depth=’Lettre’ ">h4</xsl:when>
<xsl:otherwise>h4</xsl:otherwise>

</xsl:choose>
</xsl:variable>

<xsl:element name="{$baliseVar}">
<xsl:value-of select="./@number"/>)
<xsl:value-of select"."/>
</xsl:element>
</xsl:template>

On ne gagne pas immédiatement en nombre de lignes, mais beaucoup en clarté, car les deux problèmes sont clairement disjoints. Attention toutefois à l’utilisation des accolades dans <xsl:element name="{$baliseVar}"> , car contrairement au PHP, "$baliseVar" ne sera pas traité par le processeur XSLT comme une variable, mais comme un texte normal.

L’utilisation des variables en XSLT est très efficace pour se sortir des sentiers tortueux d’XPATH. Mais XSLT a ses limites, et je conseille fortement de faire les opérations les plus complexes avec un langage comme Java & JDOM.

Cette astuce du jour propose de préparer un peu le terrain en créant dynamiquement sur la page du contenu HTML. Nous verrons dans des articles plus fouillés comment enregistrer la modification sur le serveur.
Le deuxième objectif est de documenter en français la fonction Element#insert( ) de Prototype, qui a ce jour a été « oubliée » par les faiseurs de documentation.

Voici comment créer un Element HTML à l’intérieur d’un autre élément :

<script type="text/javascript" src="js/prototype.js"></script>

<div id="haut">Haut</div>
<div id="bas">Bas</div>

<script type="text/javascript">
/* Création de l’élément */
var numero = new Element(‘h3′, { ‘class': ‘pNumber’ }).update(‘Titre’);
/* Insertion de l’élément */
$(‘haut’).insert( {bottom: numero});

</script>

« Mon dieu quelle horreur ! » s’écrierait tout programmeur orthodoxe de Java. J’en fus et pourtant cette écriture complexe est extrèmement productive. Le fait d’être compact est également un plus quand c’est mélangé au milieu du XHTML.

Pour la création de l’élément, vous trouverez la documentation et les exemples ici. L’insertion de l’élément necessite plus d’explications :

$(‘haut’) correspond bien-sûr à l’élément HTML ayant pour id : ‘haut’. Pour les non-initiés à Prototype, cela correspond à document.getElementById(‘haut’); tout en s’assurant que $(‘haut’) aura des propriétés compatibles avec tous les navigateurs.

{bottom : numero} contient d’une part la position, puis l’élément OU le contenu à rajouter.
On peut par exemple faire :

$('haut').insert( {after: '<h3 class="pClass">Petit paragraph</h3>'});
$('haut').insert( {before: 'Un peu de texte, sans balise'});

Il y a quatre positions possibles : before, after, top , bottom. Voici ce que les différentes positions donnent en pratique avec le code suivant :

var numero = new Element('h3', { 'class': 'pNumber' }).update('Titre'); /* nouvel element */  
$('haut').insert( {position : numero }); /* Insertion */

Ces quatres possibilités rendent l’ajout d’Elements bien plus aisés que le temps du document.write(…). Attention toutefois au style de programmation : comme pour le PHP et sans doute le Ruby, on peut toutefois facilement faire proliférer les abominables guillemets simples, doubles et backslachés.

Dernière astuce :il est possible de raccourcir l’écriture en se passant de la position et des accolades en écrivant simplement :

$('haut').insert( numero);

Cela revient à utiliser la position bottom, ce qui sera probablement 80% de vos insertions.