La minification d'un fichier consiste à supprimer les espaces inutiles, les commentaires et les retour à la ligne.
A titre d'exemple, le framework jquery non minifié fait 157Ko et une fois réduit, il n'en fait plus que 23Ko , la taille est pratiquement divisée par 7.
Le principal inconvénient est de rendre les fichiers plus difficiles par un humain. Dans cet article, je vais vous présenter une façon d'activer et désactiver cette minification sur les fichiers Javascript et CSS d'un projet web java.

maven-javascript-plugin

Ce plugin maven est utilisé par le framework Richfaces pour compresser les différentes librairies qui le composent (proptotype, scriptaculous) ainsi que ses propres fonctions internes. Ce plugin  (parmi d'autres) est packagé avec le framework Richfaces. Ce plugin est basé sur YUI compressor.

Vous devez donc référencer le repository jboss http://repository.jboss.com/maven2/ pour pouvoir récupérer ce plugin. Ajouter les lignes suivantes dans votre pom :

<plugin>
	<groupId>org.richfaces.cdk</groupId>
	<artifactId>maven-javascript-plugin</artifactId>
	<version>3.3.CR1</version>
</plugin>

Ci dessous un exemple de projet :

Ce projet contient 2 fichiers javascript.
Nous allons configurer le plugin maven pour qu'il regroupe en un seul les fichiers JS.

<outputDirectory>${basedir}/src/main/webapp/js/</outputDirectory>
                    <aggregations>
                        <aggregation>
                            <includes>
                                <!-- liste des fichiers a ajouter au fichier final javascript -->
                                <include>${project.build.directory}/${project.build.finalName}/js/1-min.js</include>
                                <include>${project.build.directory}/${project.build.finalName}/js/2-min.js</include>
                            </includes>
                            <!-- fichier unique  -->
                            <output>${basedir}/src/main/webapp/js/all.js</output>
                        </aggregation>
                    </aggregations>
                    <excludes>
                        <exclude>**/all.js</exclude>
                    </excludes>
                </configuration>

Tous les fichiers javascript se trouvant dans la webapp vont être minifiés à l'exception de ceux indiqués dans les exclusions du plugin (ici all.js car celui ci contiendra l'aggregation de nos fichiers javascripts minifiés).
Ensuite on configure les aggregations, on indique alors que notre fichier all.js contiendra en fait 1-min.js et 2-min.js

Pour lancer la compression des fichiers javascripts il suffira ensuite de lancer le goal suivant :

mvn javascript:compress

Notez que vous lancer ce goal a chaque fois que vous voudrez minifier vos fichiers javascript. Vous pouvez aussi automatisez cette tache, de manière à ce que celle-ci à chaque clean install du projet

Pour cela il faut ajouter les lignes suivantes :

 <executions>
                    <execution>
                        <goals>
                            <goal>compress</goal>
                        </goals>
                    </execution>
                </executions>

Ce qui au final donnera la configuration suivante :

 <build>
<plugins>
...
 <plugin>
                <groupId>org.richfaces.cdk</groupId>
                <artifactId>maven-javascript-plugin</artifactId>
                <version>3.3.3-CR1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compress</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>

                    <outputDirectory>${basedir}/src/main/webapp/js/</outputDirectory>

                    <aggregations>
                        <aggregation>
                            <includes>
                                <!-- liste des fichiers a ajouter au fichier final javascript -->
                                <include>${project.build.directory}/${project.build.finalName}/js/1-min.js</include>
                                <include>${project.build.directory}/${project.build.finalName}/js/2-min.js</include>
                            </includes>
                            <!-- fichier unique  -->
                            <output>${basedir}/src/main/webapp/js/all.js</output>
                        </aggregation>
                    </aggregations>

                    <excludes>
                        <exclude>**/all.js</exclude>
                    </excludes>
                </configuration>
            </plugin>
</plugins>
</build>

De plus, si votre projet web est un projet JSF2, vous pouvez référencer ou non les fichiers minifiés, en les liant au projectStage
Developpement = fichiers non minifiés
Production = fichiers minifiés

Hier soir, j'ai fait avec François PETITIT une présentation sur JSF2 au parisjug.

Vous pouvez récupérer le code source ici : http://www.cestpasdur.com/svn/webapp-contacts-jsf2/trunk/

Les slides sont également disponibles ici

JSF est basé sur une vue arborescente de composants dont l'état est maintenu côté serveur.
En fonction des événements, du scope des managedBean et des actions qui ont été effectuées, la valeur des composants présente dans cet arbre peut évoluer. Ce court article vous présente deux façons d'afficher cet arbre valorisé à un instant T

Debug mode de facelet

Facelet fourni un tag permettant d'afficher vie une combinaison de touche, l'arbre valorisé, ainsi que les variables et leur scope.

Il faut ajouter dans votre fichier web.xml

 <context-param>
        <param-name>facelets.DEVELOPMENT</param-name>
        <param-value>true</param-value>
    </context-param>

Ensuite, il suffit de positionner le code suivant dans votre template de page, pour le rendre disponible dans toutes vos pages.

<ui:debug hotkey="d" rendered="#{initParam.debugMode}"/>

l'attribut rendered permettra d'afficher ce composant uniquement quand facelets.DEVELOPMENT defini dans votre fichier web.xml sera positionné à true

Exemple de ce que vous pourrez obtenir en appuyant sur les touches CTRL + SHIFT + D :

DebugUtil, ou comment dumper dans la console l'arbre JSF valorise

JSF fourni une classe (pas très connue) : DebugUtil, celle ci fourni des méthodes du types :

• public static String printTree(UIComponent root)
• public static void printTree(UIComponent root, Logger logger, Level level)

Avec cette classe vous pourrez donc sortir via votre console, ou vos logger le contenu de l'arbre JSF.
Ce qui vous donnera quelque chose du type :

Cette classe peut être ajoutée dans un phaseListener pour observer, dans une phase donnée (RESTORE-VIEW et RENDER_RESPONSE par exemple) l'évolution de l'arbre JSF par exemple.

public class ViewRootPhaseListener implements PhaseListener {

    @Override
    public void afterPhase(PhaseEvent phaseEvent) {
        if (isDeveloppementMode()) {
            //ecrit dans la console le contenu de la vue
            DebugUtil.printTree(FacesContext.getCurrentInstance().getViewRoot(), System.out);
        }
    }

    private boolean isDeveloppementMode() {
        return "true".equals(FacesContext.getCurrentInstance().getExternalContext().getInitParameter(FaceletViewHandler.PARAM_DEVELOPMENT));
    }

    @Override
    public void beforePhase(PhaseEvent arg0) {
    }

    @Override
    public PhaseId getPhaseId() {
        return PhaseId.RENDER_RESPONSE;
    }
}

En savoir plus

docbook de facelet : debug-mode

Au cours de cette présentation, nous aborderons l'historique de JSF, les concepts généraux, les nouveautés introduites par cette nouvelle version :

* configuration facilitée,
* ajax natif,
* gestion des ressources,
* ...

Nous verrons également l'outillage existant, et mettrons le tout en pratique en initiant un projet de gestion de contact.

Venez nombreux.

Plus d'information sur la présentation JSF2 au Paris JUG

Actuellement je bosse sur des application web jsf2 et/ou java EE 6. Les librairies ne sont pas encore figées, donc de nombreux mises à jour arrivent régulièrement.
Le plugin maven version-maven-plugin peut vous informer facilement des mises à jour. de librairies, et même des plugins
Celui-ci a été releasé le 23 août dernier en version final 1.0.

Je vous propose maintenant de mettre en place ce plugin lors de l'execution du goal install sur vos projets.

pom.xml

<build>
<plugins>
...
<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>versions-maven-plugin</artifactId>
				<version>1.0</version>
				<executions>
					<execution>
						<phase>install</phase>
						<configuration>
					<comparisonMethod>mercury</comparisonMethod>
				</configuration>
						<goals>
							<goal>display-dependency-updates</goal>
							<goal>display-plugin-updates</goal>
						</goals>
					</execution>
				</executions>

			</plugin>

...
</plugins>
</build>

Désormais lorsque vous lancerez un install vous aurez quelque chose du genre :

[INFO] [versions:display-dependency-updates {execution: default}]
[INFO] The following dependencies in Dependencies are using the newst version:
[INFO] com.sun.faces:jsf-api ...................................... 2.0.0-b17
[INFO] com.sun.faces:jsf-impl ..................................... 2.0.0-b17
[INFO] javax.el:el-api ............................................ 2.1.2-b04
[INFO] javax.el:el-ri ................................................... 1.2
[INFO] javax.servlet.jsp:jsp-api ........................................ 2.1
[INFO]
[INFO] The following dependencies in Dependencies have newer versions:
[INFO] javax.servlet:servlet-api ................................. 2.4 -> 2.5
[INFO]
[INFO] [versions:display-plugin-updates {execution: default}]
[INFO]
[INFO] The following plugin updates are available:
[INFO] maven-clean-plugin ....................................... 2.2 -> 2.3
[INFO] maven-eclipse-plugin ..................................... 2.6 -> 2.7
[INFO] maven-install-plugin ..................................... 2.2 -> 2.3
[INFO] maven-resources-plugin ................................... 2.3 -> 2.4
[INFO] maven-site-plugin ............................... 2.0-beta-7 -> 2.0.1
[INFO] maven-war-plugin .......................... 2.1-alpha-2 -> 2.1-beta-1
[INFO] org.mortbay.jetty:maven-jetty-plugin ............... 6.1.11 -> 6.1.20
[INFO]
[WARNING] The following plugins do not have their version specified:
[WARNING] maven-clean-plugin .......................... (from super-pom) 2.3
[WARNING] maven-deploy-plugin ......................... (from super-pom) 2.4
[WARNING] maven-site-plugin ......................... (from super-pom) 2.0.1

Comme vous pouvez le voir nous avons désormais la liste des librairies et plugins à mettre à jour.
Nous pouvons même être notifié des plugins n'ayant pas de version spécifiée dans le super-pom ce qui peut s'avérer dangeureux, si vous ne définissez pas vous même ces versions (mode update automatique.

Le plugin versions-maven-plugin a d'autres possibilités. Je vous invite à consulter le site de codegaus pour en savoir +:
http://mojo.codehaus.org/versions-maven-plugin/index.html

Codes et explications

Je suis parti from scratch et j'ai suivi les indications sur la page suivante http://docs.codehaus.org/display/GROOVY/GMaven+-+Implementing+Maven+Plugins

J'ai tout d'abord créé l'arborescence suivante :

src/it : contiendra les tests d'intégration ( convention chez maven)
src/main
src/main/groovy (contiendra le code source groovy
src/main/groovy/com
src/main/groovy/com/cestpasdur
src/main/groovy/com/cestpasdur/maven
src/main/groovy/com/cestpasdur/maven/samples/
src/main/groovy/com/cestpasdur/maven/samples/HelloworldMojo.groovy (Notre premier mojo)
src/test/groovy (les tests unitaires )

Contenu de pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project>
    <modelVersion>4.0.0</modelVersion>

  <!-- Description de l'artifact -->
    <groupId>com.cestpasdur.maven</groupId>
    <artifactId>maven-helloworld-plugin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>Exemple Groovy Mojo - maven-helloworld-plugin</name>

  <!-- Les plugins maven ont leur packaging propre-->
    <packaging>maven-plugin</packaging>

  <properties>
      <gmaven.version>1.0-rc-5</gmaven.version>

  </properties>

 <!-- Dépendances -->
    <dependencies>
        <dependency>
            <groupId>org.codehaus.groovy.maven</groupId>
            <artifactId>gmaven-mojo</artifactId>
            <version>${gmaven.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Permet de générer les descripteurs de mojo présents dans le code source-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-plugin-plugin</artifactId>
                <version>2.5</version>
            </plugin>

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>groovy-maven-plugin</artifactId>
                <version>${gmaven.version}</version>
                <extensions>true</extensions>
                <executions>
                    <execution>
                        <goals>
                            <!-- Génère les stubs java à partir de mojo groovy -->
                            <goal>generateStubs</goal>

                           <!-- Compile le code source groovy-->
                            <goal>compile</goal>

                            <!-- Génère les stubs java à partir de mojo groovy  pour les Tests unitaires (TU)-->
                            <goal>generateTestStubs</goal>

                            <!-- Compile le code source des TU groovy-->
                            <goal>testCompile</goal>

                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Contenu du HelloworldMojo

package com.cestpasdur.maven.samples

import org.codehaus.groovy.maven.mojo.GroovyMojo

/**
 * description
 *
 *@goal hello
 */
class HelloworldMojo extends GroovyMojo{

    /**
     * Dit bonjour à l'utilisateur
     *
     */
    void execute(){
        log.info("hello world")
    }
}

Maintenant que le code est terminé, il serait intéressant de vérifier que ce que fait ce plugin (pas grand chose) et que cela correspond à ce l'on attend de lui.

mvn clean install

Sortie console :

NetBeans: Executing '/developpement/apache-maven-2.1.0/bin/mvn -Dnetbeans.execution=true clean install'
NetBeans:      JAVA_HOME =/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Home
Scanning for projects...
------------------------------------------------------------------------
Building Exemple Groovy Mojo - maven-helloworld-plugin
   task-segment: [clean, install]
------------------------------------------------------------------------
[clean:clean]
Deleting directory /developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/target
[groovy:generateStubs {execution: default}]
 Generated 1 Java stub
[plugin:descriptor]
[WARNING] Using platform encoding (MacRoman actually) to read mojo metadata, i.e. build is platform dependent!
Applying mojo extractor for language: java
Mojo extractor for language: java found 1 mojo descriptors.
Applying mojo extractor for language: bsh
Mojo extractor for language: bsh found 0 mojo descriptors.
[resources:resources]
[WARNING] Using platform encoding (MacRoman actually) to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory /developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/src/main/resources
[compiler:compile]
Compiling 1 source file to /developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/target/classes
[groovy:compile {execution: default}]
 Compiled 1 Groovy class
[groovy:generateTestStubs {execution: default}]
 No sources found for Java stub generation
[resources:testResources]
[WARNING] Using platform encoding (MacRoman actually) to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory /developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/src/test/resources
[compiler:testCompile]
Nothing to compile - all classes are up to date
[groovy:testCompile {execution: default}]
 No sources found to compile
[surefire:test]
No tests to run.
[jar:jar]
Building jar: /developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/target/maven-helloworld-plugin-1.0-SNAPSHOT.jar
[plugin:addPluginArtifactMetadata]
[install:install]
Installing /developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/target/maven-helloworld-plugin-1.0-SNAPSHOT.jar to /Users/damiengouyette/.m2/repository/com/cestpasdur/maven/maven-helloworld-plugin/1.0-SNAPSHOT/maven-helloworld-plugin-1.0-SNAPSHOT.jar
[plugin:updateRegistry]
------------------------------------------------------------------------
BUILD SUCCESSFUL
------------------------------------------------------------------------
Total time: 8 seconds
Finished at: Sun Jun 28 09:24:25 CEST 2009
Final Memory: 21M/38M
------------------------------------------------------------------------

Comme vous pouvez le voir j'utilise Netbeans pour coder ce magnifique plugin en groovy car le support est pour le moment meilleur que dans Eclipse (espérons que le rachat de g2one par springsource arrange les choses de ce côté là)

On voit tout d'abord qu'un stub java est généré dont voici le code ci-dessous

//
// Generated stub from file:/developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/src/main/groovy/com/cestpasdur/maven/samples/HelloworldMojo.groovy
//

package com.cestpasdur.maven.samples;

import java.lang.*;
import java.io.*;
import java.net.*;
import java.util.*;
import groovy.lang.*;
import groovy.util.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.codehaus.groovy.maven.mojo.GroovyMojo;

/**
 * description
 *
 * @goal hello
 */
public class HelloworldMojo
    extends GroovyMojo
    implements groovy.lang.GroovyObject
{
    /**
     * Dit bonjour ˆ l'utilisateur
     */
    public void execute() {
        throw new InternalError("Stubbed method");
    }

    public groovy.lang.MetaClass getMetaClass() {
        throw new InternalError("Stubbed method");
    }

    public void setMetaClass(groovy.lang.MetaClass metaClass) {
        throw new InternalError("Stubbed method");
    }

    public java.lang.Object invokeMethod(java.lang.String name, java.lang.Object args) {
        throw new InternalError("Stubbed method");
    }

    public java.lang.Object getProperty(java.lang.String name) {
        throw new InternalError("Stubbed method");
    }

    public void setProperty(java.lang.String name, java.lang.Object value) {
        throw new InternalError("Stubbed method");
    }
}

On peut également voir un warning dans la console :

[WARNING] Using platform encoding (MacRoman actually) to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory /developpement/workspaces/WS-ganymede/maven/maven-helloworld-plugin/src/test/resources

Je suis un mac user, et sur Mac nous avons la change/malchance (choisissez) d'avoir notre propre encodage par défaut. Afin de corriger çà il suffit d'ajouter dans le pom.xml :

...
 <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <!-- Permet de spécifier l'encoding en UTF8 lors du traitement des ressources-->
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <!-- Permet de générer les descripteurs de mojo présents dans le code source-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-plugin-plugin</artifactId>
                <version>2.5</version>
                 <configuration>
                    <!-- Permet de spécifier l'encoding en UTF8 lors du traitement des descripteurs de mojo-->
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
...

Désormais, plus de warning dans la console :

...
[plugin:descriptor]
Using 'UTF-8' encoding to read mojo metadata.
...
resources:testResources]
Using 'UTF-8' encoding to copy filtered resources.
...

Tester son plugin

Pour tester mon plugin, je lance la commande suivante à la racine de mon projet :

mvn com.cestpasdur.maven:maven-helloworld-plugin:1.0-SNAPSHOT:hello

Résultat :

...
INFO] ------------------------------------------------------------------------
[ERROR] BUILD ERROR
[INFO] ------------------------------------------------------------------------
[INFO] Internal error in the plugin manager executing goal 'com.cestpasdur.maven:maven-helloworld-plugin:1.0-SNAPSHOT:hello': Unable to load the mojo 'com.cestpasdur.maven:maven-helloworld-plugin:1.0-SNAPSHOT:hello' in the plugin 'com.cestpasdur.maven:maven-helloworld-plugin'. A required class is missing: [Lorg/codehaus/groovy/runtime/callsite/CallSite;
org.codehaus.groovy.runtime.callsite.CallSite
...

Je n'ai pas trouvé d'autre moyen que de changer la version en rc4, ce qui a corrigé le bug (j'en ai profité pour ouvrir un bug : http://jira.codehaus.org/browse/MGROOVY-206)

Re clean install

mvn clean install

Je relance le plugin et cette fois, cela fonctionne. Mission accomplie :

macbook-pro-de-damien-gouyette:maven-helloworld-plugin damiengouyette$ mvn com.cestpasdur.maven:maven-helloworld-plugin:1.0-SNAPSHOT:hello
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building Exemple Groovy Mojo - maven-helloworld-plugin
[INFO]    task-segment: [com.cestpasdur.maven:maven-helloworld-plugin:1.0-SNAPSHOT:hello]
[INFO] ------------------------------------------------------------------------
[INFO] [helloworld:hello]
[INFO] hello world
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Sun Jun 28 11:04:27 CEST 2009
[INFO] Final Memory: 11M/80M
[INFO] ------------------------------------------------------------------------

...

Code source

source maven-helloworld-plugin

En savoir +

http://groovy.codehaus.org/GMaven+-+Implementing+Maven+Plugins
http://www.sonatype.com/books/maven-book/reference/writing-plugins-alternative-sect-writing-groovy.html

Je vous invite à télécharger le code source de gmaven ici : https://svn.codehaus.org/groovy/gmaven/trunk
Le trunk contient actuellement des exemples de mojo qui existent déjà en java (cleanMojo, installMojo), mais cette fois, ils sont codés en groovy.

Si comme moi vous avez navigué entre une dizaine de CMS, et proposé à vos utilisateurs des flux RSS avec des URL diverses et variées, vous vous retrouvez alors avec des utilisateurs qui suivent votre flux RSS avec google Reader, Netvibes ou bien leur propre butineur perso.

Seulement maintenant, vous souhaitez, à la fois économiser la bande passante consommée par les X bots, tout en utilisant les statistiques assez fournies mises à disposition par l’application de google : feedburner.

.htaccess, c’est quoi ?

Le fichier .htaccess est une solution simple pour rediriger l’utilisateur vers d’autres pages ou demander à ce que l’internaute soit authentifié.

La première étape est d’identifier si l’utilisateur courant est ou non feedburner.

Afin de lister les différents types de user agent butinant mes flux RSS, je fais via ma console préférée (celle de macos)

Auditer ses logs

cat access_log | grep feed

Vous obtiendrez donc quelque chose du style :

...
[15/Mar/2009:01:19:08 +0100] "GET /feed.php HTTP/1.0" 404 180 "-" "Netvibes (http://www.netvibes.com/; 9 subscribers; feedId: 5309207)"
...
[15/Mar/2009:11:55:44 +0100] "GET /feed HTTP/1.1" 301 213 "-" "Feedfetcher-Google; (+http://www.google.com/feedfetcher.html; 20 subscribers; feed-id=5711376032720528433)"
...
[15/Mar/2009:11:49:18 +0100] "GET /spip.php?page=backend&id_rubrique=1 HTTP/1.1" 200 23490 "-" "Feedfetcher-Google; (+http://www.google.com/feedfetcher.html; 1 subscribers; feed-id=13943281175051610867)"
...
[15/Mar/2009:09:00:32 +0100] "GET /feed HTTP/1.1" 301 213 "-" "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.19) Gecko/20090105 Lightning/0.9 Thunderbird/2.0.0.19"
...
[15/Mar/2009:07:58:50 +0100] "GET /feed HTTP/1.0" 301 213 "-" "FeedBurner/1.0 (http://www.FeedBurner.com)"
...

Comme vous pouvez le voir, les outils pour suivre les flux sont assez nombreux :

Gregarius (connait pas, celui là)

Règles de redirection (RewriteCond)

Maintenant que nous avons identifié les personnes à rediriger, nous allons pouvoir transformer cela en règle, grâce à notre fichier .htaccess en écrivant des conditions de redirection RewriteCond

Rediriger les users agents différents de feedburner :

RewriteCond %{HTTP_USER_AGENT} !FeedBurner

Règle de réécriture (RewriteRule)

Cela n’est pas suffisant, car dans ce cas, toutes nos urls seront redirigées. Il faut maintenant appliquer quelques restrictions :

Après avoir lister les urls à rediriger, cela donne :

...
RewriteRule ^feed.php$ http://feeds2.feedburner.com/CestpasdurcomTutoriauxEtRessourcesDuWeb [R=301]
RewriteRule ^feed$ http://feeds2.feedburner.com/CestpasdurcomTutoriauxEtRessourcesDuWeb [R=301,L]
RewriteRule ^spip.php?page=backend$ http://feeds2.feedburner.com/CestpasdurcomTutoriauxEtRessourcesDuWeb [R=301,L]
...

Tester les redirections

Deux méthodes :

Avec firefox en utilisant le plugin User Agent Switcher

Avec wget pour les utilisateurs par defaut sur les feed

wget http://www.cestpasdur.com/feed

Le serveur nous retourne :

--12:46:01--  http://www.cestpasdur.com/feed
          => `feed'
Résolution de www.cestpasdur.com... 88.191.80.17
Connexion vers www.cestpasdur.com|88.191.80.17|:80... connecté.
requête HTTP transmise, en attente de la réponse... 301 Moved Permanently
Emplacement: http://feeds2.feedburner.com/CestpasdurcomTutoriauxEtRessourcesDuWeb [suivant]
--12:46:01--  http://feeds2.feedburner.com/CestpasdurcomTutoriauxEtRessourcesDuWeb
          => `CestpasdurcomTutoriauxEtRessourcesDuWeb'
Résolution de feeds2.feedburner.com... 74.125.43.118
Connexion vers feeds2.feedburner.com|74.125.43.118|:80... connecté.
requête HTTP transmise, en attente de la réponse... 200 OK
Longueur: non spécifié [text/xml]

Vérifions maintenant que feedburner, lui, ne sera pas redirigé :

wget --user-agent=FeedBurner wget --user-agent=FeedBurner http://www.cestpasdur.com/spip.php?page=backend

Le retour :

--12:54:54--  http://www.cestpasdur.com/spip.php?page=backend
          => `spip.php?page=backend.2'
Résolution de www.cestpasdur.com... 88.191.80.17
Connexion vers www.cestpasdur.com|88.191.80.17|:80... connecté.
requête HTTP transmise, en attente de la réponse... 200 OK
Longueur: non spécifié [text/xml]

Code http de la réponse 200, c’est ok

Règles au complet

RewriteCond %{HTTP_USER_AGENT} !FeedBurner
RewriteRule ^feed$ http://feeds2.feedburner.com/CestpasdurcomTutoriauxEtRessourcesDuWeb [R=301,L]
RewriteCond %{HTTP_USER_AGENT} !FeedBurner
RewriteCond %{QUERY_STRING} page=backend
RewriteCond %{QUERY_STRING} !id_rubrique
RewriteRule ^spip.php$ http://feeds2.feedburner.com/CestpasdurcomTutoriauxEtRessourcesDuWeb [R=301,L]

Conclusion

Nombreux sont les CMS php vous permettant de gérer votre contenu, l’utilisation d’un fichier htaccess fonctionnera cependant avec tous. Faites attention cependant aux url qui peuvent être différentes selon le CMS utilisé. Soyez également vigilants en surveillant de prêt vos fichiers de logs après la mise en place des règles, car l’erreur est humaine.

Autre avantage, après le rachat de feeburner par google, il est possible de monétiser ses flux RSS, la manipulation précédente vous permet de mieux diffuser ces publicités.

Il vous faudra ensuite être patient car les statistiques feedburner ne seront mises à jour que le lendemain.

• Support ajax natif,
• gestions des ressources,
• Page Declaration Language et création de composants facilité (ezcomp),
• Davantage de scopes,
• Configuration facilitée,

Configuration facilitée

L’utilisation des annotation permet avec JSF2 de considérablement simplifier sa configuration. Il n’est même plus nécessaire d’avoir un faces-config dans votre projet Web.

Quelques unes des annotation ajoutées :

• @ManagedBean,
• @SessionScoped,
• @RequestScoped,
• @ViewScoped ...

Support ajax natif

De nos jours, une application web se doit d’offrir une interface riche et réactive. Cette réactivité s’obtient en ne mettant à jour que de petites portions de la page. Les versions précédentes de JSF ne proposaient aucune solution native. Des librairies tierces telles que a4jsf comblaient cette lacune en apportant leur propre solution.

Ceci au prix d’un alourdissement du code html généré et selon l’utilisation qui en est faite, au détriment des performances. JSF 2 apporte sa propre solution native.

Afin d’intégrer ajax dans vos pages, il faut dans un premier temps ajouter la ressource javascript ajax.js présente dans la librairie jsf-api.jar avec la ligne suivante :

<h:outputAjaxScript target="head" /> 

Vous pouvez ensuite l’utiliser dans vos formulaires en ajoutant sur un commandButton les attributs suivants :

onclick="jsf.ajax.request(this, event, {execute:'this, inputComponent1,inputComponent1,',render:'tableListContact'});
actionListener="#{contactBean.doCreateContact}"

Les valeurs des composants inputComponent1 et inputComponent2 seront transmises côté serveur .

En appelant FacesContext.isAjaxRequest() le serveur peut savoir si la requête qui lui est adressée est partielle ou complète. Si c’est une requête partielle (ajax), le serveur va alors consulter la liste des composants devant être mis à jour côté serveur. Les traitements et le rendu (Différentes phases du cylce de vie) ne seront effectués que sur les composants passée en références.

Si les données sont valides, la liste des contacts se verra finalement enrichie d’un nouveau membre.

Page Declaration Language (PDL)

PDL est basé sur facelets

Celui-ci fourni une méthode simple pour factoriser des morceaux de pages en éléments réutilisables et configurable : les templates. La définition d’un template est très ressemblante à celle d’un composant JSF, il est d’ailleurs très facile de réaliser des composants avec facelets, le tout sans écrire la moindre ligne de code java.

Pour les adeptes de xsl, la création d’un template avec facelets est très proche de la façon de le faire avec XSL, de la même façon, vous pouvez passer des paramètres à ce template.

Une page JSP sera compilée en une servlet, alors qu’un template facelets sera directement buildé en un arbre de composant correspondants (fonctionnement natif de JSF)

Gestions des ressources

Une ressource telle que la concoit JSF est un élément statique qui sera transmise pour être affichée ou traitée par le navigateur du client. Cela peut être une image, un script javascript, une feuille de style CSS. Une ressource est définie par :

• library,
• name,
• version,
• locale (Vous pouvez donc avoir des ressources localisées)

Précédemment dans JSF, lorsque vous vouliez mettre à disposition une ressource, vous deviez passer par le répertoire WEB-INF, afin que le navigateur client puisse y accéder, et si vous souhaitiez la mettre à jour, il fallait remplacer le fichier. Avec JSF 2.0, c’est fini, vous fournissez vos ressources directement par le biais d’un jar. Plus besoin de passer par une servlet filter. Les jars étant versionnés, il est facile d’effectuer une montée de version afin de passer des correctifs par exemple.

Afin de mettre à disposition une ressource dans un jar il faut la disposer sous /resources ou /META-INF/resources

Davantage de scope

Un nouveau scope a été ajouté, viewScope, ce qui donne au managedBean associé une durée de vie identique à celle de la view (une view peut s’étaler sur plusieurs requêtes), mais dès que vous changez de view, les données ne seront plus maintenues.

Conclusion

Même si JSF2 ne changera pas beaucoup votre façon de coder des pages web en java, il vous simplifiera la vie, par l’intégration des frameworks actuels qui étendent JSF 1.X.

De plus, lorsque vous coderez votre première page avec JSF2, vous pourrez déjà réaliser quelques pages web avant de commencer à devoir l’aller chercher des librairies tierces.

Et pour finir, la facilité avec laquelle l’on peut créer des composants en JSF2 est telle que je suis sur que nous allons voir arriver beaucoup de nouvelles librairies arriver sur le marché (openSource ou non)

En savoir +

Si vous souhaitez en savoir +, je vous invite à surveiller la sortie du livre d’Antonio Goncalves :

http://www.apress.com/book/view/1430219548

Références :

• http://weblogs.java.net/blog/edburns/
• http://weblogs.java.net/blog/driscoll/
• http://in.relation.to/10463.lace
• Liste de librairies tierces : http://www.jsfmatrix.net/

Tracer les requêtes SQL

On interagit avec une base de données via des ordres SQL. Afin de vérifier que des dizaines de requêtes ne sont pas exécutées lorsque je récupère une collection d’objet, il suffit d’activer le show_sql sur hibernate, je vais également activer le sql_comments que m’en dit encore un peu plus

Fichier de configuration spring :

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
...
<property name="hibernateProperties">
<value>
hibernate.show_sql=true
use_sql_comments=true
</value>
</property>
...
</bean>

Avec cette configuration, vous aurez en premier lieu, un commentaire sur le traitement JPA lancé (un criteria par exemples), ensuite vous verrez la ou les requêtes SQL résulstantes.

Tracer la valeur des paramètres hibernate

Vos requêtes SQL sont désormais bien tracées, cependant, la valeur des paramètres est remplacée par le caractère ? Pour afficher la valeur de ce paramètre, il suffit d’ajouter dans votre fichier de configuration log4j :

<logger name="org.hibernate.type" additivity="false">
<level value="debug" />
<appender-ref ref="console" />
</logger>

Et maintenant, vous verrez dans votre console les traces suivantes :

Hibernate: /* criteria query */ select this_.id as id4_0_, this_.name as name4_0_, this_.nbPersonnes as nbPerson3_4_0_ from Chambre this_
2009-02-24 21:02:48,939  DEBUG [org.hibernate.type.LongType] (btpool0-0:) returning '1' as column: id4_0_
2009-02-24 21:02:48,939  DEBUG [org.hibernate.type.StringType] (btpool0-0:) returning 'STANDARD' as column: name4_0_
2009-02-24 21:02:48,939  DEBUG [org.hibernate.type.IntegerType] (btpool0-0:) returning '2' as column: nbPerson3_4_0_
2009-02-24 21:02:48,939  DEBUG [org.hibernate.type.LongType] (btpool0-0:) returning '2' as column: id4_0_
2009-02-24 21:02:48,939  DEBUG [org.hibernate.type.StringType] (btpool0-0:) returning 'SUPERIEURE' as column: name4_0_
2009-02-24 21:02:48,940  DEBUG [org.hibernate.type.IntegerType] (btpool0-0:) returning '2' as column: nbPerson3_4_0_
2009-02-24 21:02:48,940  DEBUG [org.hibernate.type.LongType] (btpool0-0:) returning '3' as column: id4_0_
2009-02-24 21:02:48,940  DEBUG [org.hibernate.type.StringType] (btpool0-0:) returning 'MEZZANINE' as column: name4_0_
2009-02-24 21:02:48,940  DEBUG [org.hibernate.type.IntegerType] (btpool0-0:) returning '4' as column: nbPerson3_4_0_
2009-02-24 21:02:48,940  DEBUG [org.hibernate.type.LongType] (btpool0-0:) returning '4' as column: id4_0_
2009-02-24 21:02:48,940  DEBUG [org.hibernate.type.StringType] (btpool0-0:) returning 'aaaaa' as column: name4_0_
2009-02-24 21:02:48,940  DEBUG [org.hibernate.type.IntegerType] (btpool0-0:) returning '5' as column: nbPerson3_4_0_

Tracer les transactions Hibernate :

Maintenant nous allons activer les logs sur les transactions hibernate, en modifiant le fichier de configuration log4j

<logger name="org.hibernate.transaction">
<level value="DEBUG" />
</logger>

Ce qui vous donnera les traces suivantes

22:08:15,518 INFO  [STDOUT] 2009-02-11 22:08:15,518  DEBUG [org.hibernate.transaction.JDBCTransaction] (http-127.0.0.1-8080-2:) begin
22:08:15,524 INFO  [STDOUT] 2009-02-11 22:08:15,524  DEBUG [org.hibernate.transaction.JDBCTransaction] (http-127.0.0.1-8080-2:) current autocommit status: true
22:08:15,524 INFO  [STDOUT] 2009-02-11 22:08:15,524  DEBUG [org.hibernate.transaction.JDBCTransaction] (http-127.0.0.1-8080-2:) disabling autocommit
22:08:15,527 INFO  [STDOUT] 2009-02-11 22:08:15,527  DEBUG [com.cestpasdur.reservation.managedbeans.back.ReservationBean] (http-127.0.0.1-8080-2:) ChambreService.create : Chambre : [id: null], [name: aaaaa]
22:08:15,537 INFO  [STDOUT] Hibernate: /* insert com.cestpasdur.reservation.domain.Chambre */ insert into Chambre (name, nbPersonnes) values (?, ?)
22:08:15,613 INFO  [STDOUT] 2009-02-11 22:08:15,613  DEBUG [org.hibernate.transaction.JDBCTransaction] (http-127.0.0.1-8080-2:) commit
22:08:15,652 INFO  [STDOUT] 2009-02-11 22:08:15,652  DEBUG [org.hibernate.transaction.JDBCTransaction] (http-127.0.0.1-8080-2:) re-enabling autocommit
22:08:15,653 INFO  [STDOUT] 2009-02-11 22:08:15,653  DEBUG [org.hibernate.transaction.JDBCTransaction] (http-127.0.0.1-8080-2:) committed JDBC Connection

Statistiques hibernate

Il est possible d’activer les statistiques sur la sessionFactory hibernate, ce qui nous permettra d’obtenir entre autre les données suivantes :

• EntityNames,
• ConnectCount,
• EntityLoadCount,
• FlushCount,
• SessionOpenCount ...

Fichier de configuration spring

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
...
<property name="hibernateProperties">
<value>
...
hibernate.generate_statistics=true
...
</value>
</property>
...
</bean>

Il faut maintenant exporter ces données via JMX

<bean id="jmxExporter"
class="org.springframework.jmx.export.MBeanExporter">
<property name="beans"
<map>
<entry key="Hibernate:name=statistics">
<ref local="statisticsBean" /
</entry>
</map>
</property
</bean>
<bean id="statisticsBean" class="org.hibernate.jmx.StatisticsService">
<property name="statisticsEnabled">
<value>true</value>
</property>
<property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean>

Si vous utilisez jboss, une console jmx est directement disponible sur le serveur :

http://localhost:8080/jmx-console/

Sinon, vous pouvez utiliser des outils tels que la JConsole fournie avec le JDK.

Conclusion

J’espère que cet article vous donnera quelques pistes concernant les traces à activer lors de vos développements. Pensez cependant à désactiver toutes ces traces en Re7 et en prod bien sûr...