Intelligents-ia

Winstone 1.0.4

Jérôme Guibert — Tue, 13 Mar 2012 13:54:00 +0100

Winstone 1.0.4 is available

one step beyond

Winstone 1.0.4 is available

You can find all the information necessary for this project on the site Google Code.

What's up

Project refactoring: dedicated module for JNDI, and test
Removing deprecated parameters (javaHome, toolsJar and commonLibFolder)
Make use of Bootstrap.extraLibrariesFolderPath from keystone project in order to specify a folder for additional jar files. Default is ./lib.
Mark session cookies as HTTP only so that it won't show to JavaScript. (from jenkins branch)
Add a ServerConfiguration object and server configuration DSL (testing purpose only)

Keystone 2.4

Jérôme Guibert — Tue, 13 Mar 2012 13:42:00 +0100

Bonjour,

la version 2.4 de keystone viens de sortir!

Quoi de neuf ?

Ajout d'un nouveaux paramètre: "BootStrap.extraLibrariesFolderPath": qui spécifie un dossier externe de libraries à ajouter au classpath, en plus de celles pouvant être embarquées. Il y a quelques projets (genre Winstone ...) qui ont beaucoup à gagné à pouvoir ajouter quelques drivers sans se cassez la tête en huit...
Quelques test unitaire en plus, (...) et quelques lièvres en moins...
De la doc sur google code

Bonjour,

la version 2.4 de keystone viens de sortir!

Quoi de neuf ?

Ajout d'un nouveaux paramètre: "BootStrap.extraLibrariesFolderPath": qui spécifie un dossier externe de libraries à ajouter au classpath, en plus de celles pouvant être embarquées. Il y a quelques projets (genre Winstone ...) qui ont beaucoup à gagné à pouvoir ajouter quelques drivers sans se cassez la tête en huit...
Quelques test unitaire en plus, (...) et quelques lièvres en moins...
De la doc sur google code

Intégration du plugin à votre POM

Ajouter le repository du plugins

<pluginRepositories>
    <pluginRepository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </pluginRepository>
</pluginRepositories>
<repositories>
    <repository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </repository>
</repositories>

Et configurer le build de votre projet avec le plugin "keystone-plugin" (indiquer votre classe de démarrage) :

<build>
    <plugins>
        <plugin>
            <groupId>org.intelligents-ia.keystone</groupId>
            <artifactId>keystone-plugin</artifactId>
            <version>2.4</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <configuration>
                        <mainClass>votre.class.Main</mainClass>
                    </configuration>
                    <goals>
                        <goal>custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Récupération des sources

Pour récupérer le code source et construire le projet (client svn et maven obligatoire) :

svn checkout https://intelligents-ia.googlecode.com/svn/trunk/keystone keystone --username yoursUserName
cd keystone
mvn clean package

Winstone 1.0.3

Jérôme Guibert — Tue, 28 Feb 2012 18:04:00 +0100

Winstone 1.0.3 est disponible

Comment ça, c'est pas trop tôt ?

Winstone 1.0.3 est disponible

Vous pourrez retrouvez toutes les informations nécessaire à ce projet sur le site de Google Code.

Quoi de neuf

L'intégration d'une multitude de patch en provenance de Jenkins Winstone.
Pour plus d'informations, je vous invite à consulter le "change log".

Et puis, quelques corrections/évolutions en plus (j'étais motivé):

Des corrections, genre:
- Mise a jour des argument de la ligne de commande
- Un problème de séparateur de path sur l'object HostConfiguration
- L'utilisation de la syntaxe jdk5
- L'ajout d'un message d'arrêt
- L'utilisation de StringBuilder
- Le début d'une api correcte autour des classes HostGroup, Cluster et JNDI depuis une instance Server.
- La javadoc et les commentaires qui vont bien
- L'utilisation du singleton Boolean
- L'ajout de l'option "webroots" en ligne de commande, qui vous permet plusieurs webapp ou qu'elle soit (pas forcement sous un même dossier)
- Le jndi manager qui ne marchait pa
- L'ajout de la dependance vers log4j
- L'ajout de plus d'information dans les logs lors du déploiement d'application
De la doc sur google code

Et la suite

J'ai quelque idées dans le ciboulot...

Exposer un API pour gérer les hosts et les webapp de manière programatique
restructurer un peu le projet winstone au niveau des modules maven
Introduire un objet "Serverconfiguration" et appliquer l'ioc au niveau des classes internes
Essayer le framework jackson pour lire les web.xml, mais le serveur va grossir un peu...
Choisir un framework de log par défaut via la facade slf4j. Pour le moment c'est log4J, mais pourquoi pas utiliser logback...
la création d'un plugin maven pour l'autodeploiement

J'ai une question existentiel:
Doit-on gardez un serveur de petite taille ou utiliser des framework externe qui font très bien le boulot?
Introduire Slf4J à rajouter 600Ko de librairies...

N'hésitez pas a me faire part de vous remarques, suggestion...

Keystone 2.3

Jérôme Guibert — Tue, 28 Feb 2012 17:26:00 +0100

la version 2.3 de keystone viens de sortir!

Il est jolie, tout beau tout chaud!!

Quoi de neuf ?

Ajout de l'option "explodeDependencies": historie de packager les dépendances à plat comme le plugin onejar (même si ma préference va clairement au respect de l'intégrité des jar inclus)
De la doc,...
Un petit mot clef "[#home]" qui dans l'option logPath sera remplacer par le répertoire racine de l'application

Bonjour,

la version 2.3 de keystone viens de sortir!

Quoi de neuf ?

Ajout de l'option "explodeDependencies": historie de packager les dépendances à plat comme le plugin onejar (même si ma préference va clairement au respect de l'intégrité des jar inclus)
De la doc,...
Un petit mot clef "[#home]" qui dans l'option logPath sera remplacer par le répertoire racine de l'application

Intégration du plugin à votre POM

Ajouter le repository du plugins

<pluginRepositories>
    <pluginRepository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </pluginRepository>
</pluginRepositories>
<repositories>
    <repository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </repository>
</repositories>

Et configurer le build de votre projet avec le plugin "keystone-plugin" (indiquer votre classe de démarrage) :

<build>
    <plugins>
        <plugin>
            <groupId>org.intelligents-ia.keystone</groupId>
            <artifactId>keystone-plugin</artifactId>
            <version>2.3</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <configuration>
                        <mainClass>votre.class.Main</mainClass>
                    </configuration>
                    <goals>
                        <goal>custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Récupération des sources

Les sources du projets ont été déplacées pour cette occasion.

Pour récupérer le code source et construire le projet (client svn et maven obligatoire) :

svn checkout https://intelligents-ia.googlecode.com/svn/trunk/keystone keystone --username yoursUserName
cd keystone
mvn clean package

Twitter Bootstrap CSS Tools

Jérôme Guibert — Tue, 21 Feb 2012 10:59:00 +0100

Twitter Bootstrap CSS Tools est un outil open source (sous Apache Licence v2.0) à essayer rapidement!

Le site officiel : http://twitter.github.com/bootstrap...

Le projet sous gitHub: https://github.com/twitter/bootstra...

C’est un framework qui rassemble :

un fichier css
des icônes standardisé et claires
un code Javascript

En grosso modo 100Kb (code et données confondus), cela vous permet de réaliser des interfaces WEB :

Standardisé et hautement fonctionnel
Dynamique (en terme d’interaction utilisateur)
Simple : regardez donc les pages web a quoi elle ressemble
Légère : je vous ferais pas l’affront de vous présenter « twitter » et les « quelques » utilisateurs qui y accèdent

De plus, cela vous affranchit des problèmes de compatibilité entre navigateur et système d'exploitation, car il supporte:

OS	BROWSER	BROWSER VERSION
OS X	Mozilla Firefox	6
OS X	Mozilla Firefox	5
OS X	Google Chrome	14
OS X	Safari	5
OS X	Opera	11
Windows	Internet Explorer	9
Windows	Internet Explorer	8
Windows	Internet Explorer	7
Windows	Google Chrome	14
Windows	Mozilla Firefox	6
Windows	Mozilla Firefox	5

La source

Vu ? Bon développement !

Premier pas en Sidemount

Jérôme Guibert — Mon, 20 Feb 2012 14:46:00 +0100

Il y a quelques mois, j'ai découvert la plongée en bouteille.

Ce fût au milieu du paysage enchanteur et magique de l'Ile Maurice, que j'ai eu l'occasion de faire mes premières bulles...
et quelles bulles!! Depuis, la plongicide aigue est toujours présente :-), j'ai enchainer l'open water, l'advance open water, le nitrox, Padi donc, et tout récement le Sidemount, SM pour les intimes, côté TDI/SSI.

Je voulais vous faire partager ma petite experience du SM, dont la philosophie KISS (Keep It Simple and Stupid) ou DIR (Do It Right), fait un très fort écho avec mon métier : architecte technique jEE...

Il y a quelques mois, j´ai découvert la plongée en bouteille.

Ce fût au milieu du paysage enchanteur et magique de l´Ile Maurice, que j´ai eu l´occasion de faire mes premières bulles...
et quelles bulles!! Depuis, la plongicide aigue est toujours présente :-), j´ai enchainer l´open water, l´advance open water, le nitrox, Padi donc, et tout récement le Sidemount, SM pour les intimes, côté TDI/SSI.

Initialement posté sur le site de plongeur.com .

Pour ceux/celles qui ne connaissent pas encore, le sidemount c´est en quelques mots: plonger avec les bouteilles de chaque côté du corps (svelte et musclé évidement...).

La plongicide aigue est assez récente chez moi: elle date d´il y a 5 mois.
J´ai le niveau AOWD + nitrox padi et seulement 13 plongées à mon actif, avant cette formation.
Alors pourquoi s´enquiquiner avec 2 bouteilles et de longs tuyaux, alors qu´il existe de bonne stab tout confort avec lecteur blue-ray et airbag ?
Ben, j´ai bien une réponse a la c... : c´est 2 fois mieux et plus c´est long plus c´est... Mais que nenni!

De la plongée soutteraine à la "frog Couic team" en passant par les longues (très longues) discussions objectives stab-versus-wing-verus-sidemount, j´ai du subi "à l´insu de mon plein grès" de long matraquage marketing avec forte publicité! mensongère ? ... un peu, sans doutes, mais rien à voir avec la plongée, soyons bien d´accord!

Reste que quand j´ai lu la premiere fois un bref récap historique de la plongée sidemount, cela m´est apparue comme un évidence:
t´apprends et tu plonges avec ce truc.

Accessoirement, ce qui m´a attiré c´est:

deux bouteilles indépendantes: redondance des gaz et des détendeurs, robinets en visu
deux bouteilles: plus grande autonomie,
deux bouteilles: mais sans le poids d´un bi c´est mieux
la configuration en mono bouteille possible (et c´est vraiment fou à quel point j´ai eu l´impression de ne rien avoir dans cette configuration)
le côté léger pour le voyage
la sensation de glisse dans l´eau sans être engoncé dans une stab,
moins de volume, donc moins de lest, donc moins d´essouflemement, donc ...
le côté nouveaux aussi bien sûr!

Quelques bonnes âmes du forum (arno22, et un certain loule06, au hasard ) m´aiguillent gentillement vers le nom de code "Yannig73", la version FR du sieur Narcosis. Je vais faire un petit tour sur son site, et l´air de rien je lis une baseline:

Survival depends on being able to suppress anxiety and replace it with calm, clear, quick and correct reasoning
Sheck Exley.

Et là, je vous passe le chambard des méninges: 13 plongées ... y va te prendre pour un titi le bonhomme, t´as vue le cursus du sieur? ...

moi les grottes à part les grottes d´Arcy et la visite en tongues...
et deux bouteilles ? déjà qu´avec une je sais pas toujours quoi en faire à pars la vider...
la plongée c´est un peu comme la bouteille de ratafia, une fois que tu y a gouté tu la termines jusqu´au bout, alors go...
pis deux mois sans plongée, j´ai la peau qui déssèche...
Pis de toute façon, c´est pour apprendre, ouais mais ma flotta, c´est tout de même récent en stab ...
et je vous parle pas de ma position de mon corps dans la colonne d´eau ...
le palmage, avec les deux mains c´est plus simple pour reculer...
Et 9 litres qu´elle fait cette z-trim, je vais jamais remonter du fond...
bref, j´ai laisser murir le bestiau un peu quoi....

Quelques rond de serviette plus tard, j´ai osé ecrire au Masta Charles Yannig, dit "le blond" sur la côte sud: Il m´a répondu tout simplement que oui, je pouvais suivre cette formation! Et voila qui me propose de faire une formation sidemount ce week end !

Résultat:

"- Chérie ??
- oui ?
- devines où on passe le week end ??
"

Et me/nous voilà parti faire une visite au berceau de la plongée: Marseille le pays où les S80 flottent dans l´eau

Un truc, c´est que j´avais pas prévue de rencontrer plein de gens sympa, chui bêta moi tiens ...
Ben oui, je suis chez les titi depuis 10 ans, j´ai presque eu peur qu´ils me mordent en arrivant, un chouilla je vous rassure quand même!

Sans rire, merci pour votre accueil! merci à Stéph et Fred de m´avoir supporté pendant la formation, coucou à niki, merci à Laurent pour le cabanon, les caouhètes, je suis heureux de partager le même secret des jolie tomates au fond du jardin!

J´ai hâte de repasser par Marseille, visité de jolie coin! et si vous passez par Paris, n´hésitez pas la montée des eaux c´est pour bientôt !
Au milieu de ces zouaves, le "jeunot" que je suis était heureux comme un poisson dans l´eau, moi je vous le dis !
y avait un petit côté irréaliste, qui me disais "tu vas te reveiller à Paris avec les touches du clavier imprimmées sur le nez toi..."

Retour au sidemount avec Yan tout sourire, qui commence par une scéance de taillage sur mesure du dit harnais ´ultimate´; En option bande rose pour les prochaines fois

En fait, la simplicité ultime du "truc" est tout de même le fruis d´un bon jus de cerveau et de moulte petite astuces; Ca respire le fruit de longues nuits de cogitation, et de moulte essaie dans l´eau. Des astuces "tellement-bêtes-que-t-y-avais-pas-pensée-encore", il y en a plein; mais pas seulement pour le harnais, y en a pour tout :
pour les bouteilles, pour le chti bout de ficelle là, qui l´air de rien te sauve la plongée en cas de soucis, sans parler du plongeur!

Et ça commence direct avec une revue de matériel;

Bilan: une fois que t´as tout (balancé) rangé dans les grande armoire judicieusement placé de sieur loule, cela deviens a peu près correct.

Lesson one: DIR ca rigole pas (ou presque)
Lesson two: si c´est pour plongée avec l´hydrodynamise d´un oursin, autant essayer un autre sport, genre la pêche tiens...

Lendemain matin, frais comme un gardon et pas encore cuit sous le dur soleil de (Bret..) Marseille: direction le montage de la config.
Voila celle de Yannig, le top quoi.

A vous de jouer. Check du boss, l´élève se sent une montée de "stress", surtout avec le sourire en coin, attendant des remarques (éventuelles) ?
"mmm, le truc là, c´est mieux dans l´autre sens."
Démo au sec, et ben oui, il a raison... forcément vous me direz... et oui... C´est ca la classe...

Quatres heures d´explications, au minimum, en ne comptant pas les mi-temps, la veille, et les conseils pendant l´aller, Yan adore parler et expliquer, et ca c´est tout de même super top pour moi

Et oui, j´ai eu droit à ma première vrai leçon de palmage façon frog-couic, j´ai un peu de boulot mais ca va venir

On s´est tout de même bien marré! On a tellement bien rigoler qu´on a pas fait vraiment gaffe au soleil qui lui nous a pas oublié...
nos peaux d´albâtres ont virer rose...
Bref, début de l´apres midi, on va commencer nôtre premiere plongée, avec:

harnais ultimate
z-trim de 9l
deux bouteilles S80 equipée (1er etage, mano, detendeur, ds)
tuyaux longs pour le tricot et tour de cou

Zou à la flotte, fesait trop chaud, c´est parti pour la découverte totale!!!

Rappellez vous que pour moi, la plus grosse manip de bloc à ce moment là ce résume à l´analyse de gaz... ben oui...

Au début, cela m´a parut bizzare d´avoir tout ce matériel à manipuler, un peu peur de me mélanger les pinceaux avec les deux détendeurs autour du coup...
Et puis, la manipulation des mousquetons ben, je le fait pas encore aussi bien que Steve, mais y a de l´idée...

Premier constat direct:

la position horizontale est grandement faciliter par la configuration du harnais.
Et la z-trim, elle pousse sacrément! va pas falloir que je rigole avec la bête moi...

C´est parti pour des scéances de palmages, de rotation, et ouch, je découvre de nouveaux muscles...

1 heures plus tard, petit breifing avant de repartir pour une deuxieme profonde

Essaie du s-drill, valve-drill, bon, j´ai encore du boulot pour remettre ma bouteille correctement, et plein de truc qui vont pas encore...
mais je me sens tout de meme plus à l´aise qu´à la première plongée:
il y a rien qui viens m´écraser le bidon, et ce sentiment de liberté/legerté dans l´eau, c´est génial!
Et quand je palme, avec mon siouper frog kick, ca pousse plus loin que d´habitude et sans gros effort, ca c´est top.
Et la manip des blocs/détendeurs ne m´effraie plus, au contraire; Je suis très loin d´avoir l´aisance de Yannig bien sûr, mais au moins j´ai bien compris le pourquoi du comment.
Et le nitrox, c´est vrai que cela fatigue moins!
Le bilan de cette première journée: c´est carrément génial! Vivement demain!!

Deuxième journée.

Au menu : Apprentissage du bubble check, répétition des s-drill, v-drill, simulation d´un débit continue et contrôle de l´ouverture de robinet pour sauver du gaz, et petit tour avec une seule bouteille.

Là, j´ai galéré grave: masque qui fuyait et plein de buée, résultat: vidage de masque toute les 2 minutes...
ah ça, j´ai bien travailler le vidage, le retrait et recalage sur le nez de ce p... masque<

Du coup, je zap de controller ma flottabilité, ma position n´en parlons pas... aiee
Là je me suis vraiment pas senti au niveau, je fais perdre du temps, je m´énerve... grr chui trop bête

Malgré ces problèmes, j´ai tout de même pu retravailler les exos, et bien: je vais m´entrainer le plus souvent possible, jusqu´a ce que j´arrive à les faire bien a plat sans bouger.
J´ai quand même capter l´essence d´un truc important: calme et isolation des problèmes (c´est la première fois que j´en avais un qui me gonflait...)

Lesson 3: Un masque bien adapté au visage c´est mieux
Lesson 4: le sidemount en mono bouteille c´est le pieds absolu!!
Lesson 5: le check de la configuration apres chaque remontage de bloc est obligatoire si je veux pouvoir donner du gaz...
Lesson 6: le bubble check c´est super important
Lesson 7: Zen attitude sous l´eau, ne doit pas empêcher l´actvité neuronale.

En faites, cette troisieme plonger m´agace, car je ai eu l´impression de rien contrôler (flota/trim, etc), j´ai subit. Je dirais pas "plus jamais", mais... je vais eviter tout de même.

Aller, petit casse-croute (Merci Stéphanie), et zou quatrième plongée avec petit tour dans l´eau.

Là, j´ai essayé un lestage a base de harnais. Hormis un petit probleme d´horizontalité (j´avais placé le poids un peu trop haut sur le corps), c´est vraiment plus confortable que la ceinture!

Cette fois, c´est plus une plongée récréative: on passe la barrière de la profondeur abyssale de 3-5 mètres, c´est que du bonheur !
Remontée le long du relief sur le dos avec les bloc devant, j´ai l´impression de glisser dans l´eau!
Passage dans un "petit" trou, première fois que il y avait autre chose que de l´eau au dessus de ma tête, c´est étrange comme sensation, et plutôt marrant!
Bon, va falloir que je m´améliore tout de même pour esperer visiter de jolie grotte... Mais ah, oui, je viens de passer la tête et les epaules dans la cavité, ben c´est que tout le reste passe, merci les inventeurs.

Descente a 17 metres, petit contrôle avec la z-trim, je me force a utiliser mes poumons le plus possible; vache! C´est top, pas besoin de plus de volume, et j´ai au moins 2 ou 3 kilos de trop.
J´ai pu voir une seiche qui viens de gober un truc devant nous !! tiens un poulpe, oh puis une langouste ? et un lièvre de mer (merci Fred pour l´explication )
Ah tiens, le bout de bungee, je l´ai mal mis, bon tant pis, j´ai compris, la prochaine fois je controlerais ce point...

Retour au bercail, dé-breifing, démontage des configurations, passage à la caisse, et ambiance chaleureuse sont au rendez-vous!

Alors convaincu? Que oui, tiens!

Je vais pas vous dire que je ne plongerais plus jamais avec une stab car je vais surement devoir passer une équivalence de niveau F2;
Et puis je serais surement obligé de démontrer de quoi je suis capable au DM pour qu´il accepte de me voir plongée en SM...
Par contre, ca oui, je suis convaincu que le SM c´est génial.

Je regrette juste un truc, c´est de ne pas avoir appris avec depuis le début!

De cette formation, j´ai beaucoup appris; La manipulation du harnais, le palmage, des contrôles de sécurité, et beaucoup plus encore...
Juste une petite chose si vous voulez essayer le SM faites le avec quelqu´un qui soit capable de vous expliquer les petits détails et spécificités de cette configuration.
D´ailleurs, j´ai appris bien plus de truc que juste le SM en particulier, et ca merci à Yannig et aux Marseillais

Le lieux du crime.

Un peu de prosélitisme

Cours gratuit de la Stanford University de Fevrier 2012

Jérôme Guibert — Mon, 20 Feb 2012 14:23:00 +0100

La célèbre université de Stanford propose une série de cours gratuit dont beaucoup vont commencer au mois de février 2012.
Ces cours sont en anglais, sous forme de vidéo, de texte à lire, tout en anglais .

Dépêchez-vous, ils ont pas encore commencé!

Pour ma part, je vais tenter de suivre ceux-ci:

Natural Language Processing de Chris Manning et Dan Jurafsky
Model Thinking de Scott E Page
Machine Learning de Andrew Ng
Human-Computer Interaction de Scott Klemmer

Et Vous ?

Maven configuration

Jérôme Guibert — Wed, 15 Feb 2012 17:41:00 +0100

Recently, I had to install several development environment, and I wanted to share with you this little setup guide for maven.
For if the installation is very simple, configuration is much less.

French Version

Ubuntu, installation boils down to :

sudo apt-get install maven2

The files are installed in the /usr/share/maven2 and configuration under /etc/maven2.

With Windows, download a maven archive and unzip it under c:\maven2. You could find maven on Apache

The files are installed in c:\maven2 and configuration c:\maven2\conf.
Check that you have environment variable (echo %NOM_VARIABLE%)

JAVA_HOME: that points to a JDK and NOT a JRE
M2_HOME: "c:\maven2"
a PATH with "c:\maven2\bin"

If this is not the case, set these values, open a new terminal, test.

Create your local repository

Create folder /usr/local/m2-repository/ (or c:\maven2\m2-repository) and set write rules for all.

It is in this folder that all libraries will be copied as your projects needed.

cd /usr/local
sudo mkdir m2-repository
sudo chmod a+w  m2-repository/

Minimal configuration

Edit the configuration file "settings.xml" to indicate where the local repository and use any mirror.

(The official maven repository is "http://repo1.maven.org/" in order to have reasonable response time we use a mirror)

<!-- local repository diractory -->
<localRepository>/usr/local/m2-repository</localRepository>
<mirrors>
<mirror>
<id>UK</id>
<name>UK Central</name>
<url>http://uk.maven.org/maven2</url>
<mirrorOf>central, maven-central-repository</mirrorOf>
</mirror>
</mirrors>

Check installation

Execute:

mvn -version

And this should give you something like this:

Apache Maven 2.2.1 (r801777; 2009-08-06 21:16:01+0200)
Java version: 1.6.0_17
Java home: /usr/local/jdk1.6.0_17/jre
Default locale: fr_FR, platform encoding: UTF-8
OS name: "linux" version: "2.6.32-24-generic-pae" arch: "i386" Family: "unix"

From that moment, you have an operational system maven.

I suggest you go a little further with repositories so you could save a lot of time.

Repositories to know

Ideally with maven and use a local repository type nexus / archiva which will serve as mirror all repository maven spread over the Internet.
In your settings.xml, you will have a configuration that looks like this:

 <mirrors>
<mirror>
<id>internal-repository</id>
<name>Maven Repository Manager running on repo.mycompany.com</name>
<url>http://repo.mycompany.com/proxy</url>
<mirrorOf>*</mirrorOf>
</mirror>
</mirrors>

Here the url "repo.mycompany.com" is the url of the repository of your company.

As the installation of a mirror is not always possible or even desired, here is another way to artificially add a list of repository for your projects.

The idea is to create a profile in the settings file that will list all the repository you wish to have by default in your projects. Then you can choose to activate it by default or upon request.

      <profiles>
<profile>
<id>my-repository</id>
<activation>
<!-- here we did not activate this profile by default -->
<activeByDefault>false</activeByDefault>
</activation>
<repositories>
<!-- list of standard repository -->
...
</repositories>
</profile>
</profiles>

To run a command using this list of maven repository, you must add "-Pmy-repository" as parameter (because the profile is not enabled by default):

mvn -Pmy-repository clean install

Now, here's a list of very useful repository:

<repository>
<id>javanet</id>
<name>Repository for Maven2</name>
<url>http://download.java.net/maven/2</url>
</repository>
<repository>
<id>google</id>
<name>Google repository for Maven2</name>
<url>https://oss.sonatype.org/content/repositories/google-releases/</url>
</repository>
<repository>
<id>jboss</id>
<name>JBoss repository for Maven2</name>
<url>http://repository.jboss.org/maven2/</url>
</repository>
<repository>
<id>com.springsource.repository.bundles.release</id>
<name>SpringSource Enterprise Bundle Repository - SpringSource Bundle Releases</name>
<url>http://repository.springsource.com/maven/bundles/release</url>
</repository>
<repository>
<id>com.springsource.repository.bundles.external</id>
<name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>
<url>http://repository.springsource.com/maven/bundles/external</url>
</repository>
<repository>
<id>com.springsource.repository.libraries.release</id>
<name>SpringSource Enterprise Bundle Repository - SpringSource Library Releases</name>
<url>http://repository.springsource.com/maven/libraries/release</url>
</repository>
<repository>
<id>com.springsource.repository.libraries.external</id>
<name>SpringSource Enterprise Bundle Repository - External Library Releases</name>
<url>http://repository.springsource.com/maven/libraries/external</url>
</repository>
<repository>
<id>intelligents-ia</id>
<name>Intelligents-ia Repository</name>
<url>http://intelligents-ia.com/maven2</url>
</repository>

You can find attached to this post, the file settings.xml ready to use

If you know of another repository it would be interesting to add, feel free to contact me :-)

How to : JPA, Hibernate & Co English-version

Jérôme Guibert — Wed, 15 Feb 2012 16:51:00 +0100

In order to be quickly operational on persistence mechanisms, and be able to create a data access layer by following current good practices, I propose with a single archive: a generic DAO, an automatic management of temporal data, and an instantiation based on annotations of JPA/Hibernate/Springframework with transaction management.

Introduction

In order to be quickly operational on persistence mechanisms, and be able to create a data access layer by following current good practices, I propose with a single archive::

a generic DAO,
an automatic management of temporal data,
an instantiation of JPA/Hibernate/Springframework with transaction management,
a model configuration configuration du model based on annotations
a sample use case

French version of this document

JPA-Utility, what else ?

In this library, you can find utilities serving to simplify the use of the trio JPA / Hibernate / Spring DAO as a generic DAO, methods course large amounts of data efficiently (the paging system is integrated), a basic to customize the names of your database tables, a dating mechanism (not carbon-14 ...) of your entities, but also a complete working example of a persistence layer to copy to keep you running quickly.

One DAO is enough, ... for beginning

You can find the class "org.intelligentsia.utility.jpa.GenericJpaDao" :

This is a class parameterized by the type of managed entity 'T' and type of the primary key used 'ID'. With this setting, it exposes :

classical methods : 'persist', 'delete'
a method for selecting primary key 'findById'.
a set of method 'findByNamedQuery' which executes a query, with parameters or not, with a paging mechanism (or without) that allows you to browse large volumes of data with a 'for' loop (see post How to browse large volume of datas with 2 lines of code)

A small classical example :

...
@Autowired
private GenericJpaDao<page, Long> pageDao;
...
// create a new page
Page page = new Page();
page.setName("home page");
pageDao.persist(page);
...

To Iterate on Site collection, you just have to do :

@Repository("siteDao")
@Scope(BeanDefinition.SCOPE_SINGLETON)
@Transactional(propagation=Propagation.SUPPORTS)
public class SiteDao extends GenericJpaDao<site, Long> {
public SiteDao() {
super();
}
@Transactional(readOnly = true)
public Iterable<site> findAll() {
return findByNamedQuery("selectAllSite", 10);
}
}
...
// For all site
for (Site site : siteDao.findAllSite()) {
// do something
}
...

When you begin your project, I invite you not to create a specific class for each entity and force you to use an instantiation via Spring.
You can add them step by step when its required for your services, add only the applications necessary for your entities.
At this point, you will add ad hoc methods on a specific DAO.

Easter Eggs, an overview

The library also includes two or three little things:

Entity Stamped

First the interface "timestamped" and its companion bean "TimeStamp" will allow you to manage your entities on the classical fields "timestamp", "creationDate" and "lastModificationDate" like this :

@Entity
@Table(name = "PAGE")
public class Page implements  Serializable, TimeStamped{
...
/**
* Time stamp data embedded in this entity
*/
@Embedded
private TimeStamp timeStamp =" ""new" TimeStamp();
@Override
public TimeStamp getTimeStamp() {
return timeStamp;
}
...

And that's all! GenericJpaDao class will handle the rest for you. For the curious, this mechanism relies on the declaration of an interface "timestamped", its bean "TimeStamp" and a little test in the method implementation "persist" on "GenericJpaDao".

/**
* if an entity implement this interface, their field 'TimeStamp' will be updated by provider.
* @author <a href="mailto:jguibert@intelligents-ia.com">Jerome Guibert</a>
* @version 1.0.0
*/
public interface TimeStamped {
public TimeStamp getTimeStamp();
}
/**
* TimeStamp offer an implementation for three common fields: timestamp, creationDate and lastModificationDate.
*
* @author <a href="mailto:jguibert@intelligents-ia.com">Jerome Guibert</a>
* @version 1.0.0
*/
public class TimeStamp implements Serializable {
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "TIMESTAMP")
protected Date timestamp;
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "LASTMODIFICATION")
protected Date lastModificationDate;
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "CREATION")
protected Date creationDate;
public TimeStamp() {
super();
}
...
}
//
public class GenericJpaDao<t extends Serializable, ID extends Serializable> {
...
public T persist(T entity) {
// here the egg
if (TimeStamped.class.isAssignableFrom(entity.getClass())) {
TimeStamp stamp = ((TimeStamped) entity).getTimeStamp();
Date current = new Date();
if ((stamp.getCreationDate() == null)) {
stamp.setCreationDate(current);
}
stamp.setLastModificationDate(current);
stamp.setTimestamp(current);
}
entityManager.persist(entity);
return entity;
}
...
}

Achieved at little cost, so far this test has not been challenged by its performance. If you want to add other functionality of this type (trace who did what, for example, ....) I invite you to extend the class GenericJpaDao or otherwise propose me the extension (I would be happy to integrate the project ).

Your DBA will be (again) your best friends (or not)

Too long abused, often relegated to the end of the chain, they can also help you (yes, but not all ...).

Rather than pretend that it did not exist, go to see him/her and explain that :

You will create a new schema (it will be happy to know at least one day before the start of production (real life. ..))
You can standardize the names of tables that you create (prefix, suffix)
You can name the tables, as it should '(see the "@ Table (name =' PAGE ')" at the beginning of each entity declaration)

And if in addition you show him a draft schema which will create later (on your local machine you should have what it takes) ...

In this way, the day (that'll never ...) where you will be out of gas on a query, that your performance read / write will most lamentable, you can ask him (very humbly) assistance (precious ) ...

To fix it-prefix-of-suffix, this is a small example :

Create a class extending "CustomTableNamingStrategy" and set the prefix / suffix of your tables.

/**
* DevTableNamingStrategy add "TEST_" prefix on all TABLE.
*
* @author <a href="mailto:jguibert@intelligents-ia.com">Jérôme Guibert</a>
* @version 1.0.0
*/
public class DevTableNamingStrategy extends CustomTableNamingStrategy {
private static final long serialVersionUID = -2544171811654641826L;
public DevTableNamingStrategy() {
super("TEST_", null);
}
}

Set the value of the property "model.hibernate.namingStrategy" on the right class: "model.hibernate.namingStrategy=org.intelligentsia.utility.jpa.DevTableNamingStrategy" (In the example provided, it will be feed the parameter "hibernate.ejb.naming_strategy").

The route of large data

I invite you to read the post Browse large volume of data in two lines of code. This is the reason for the existence of classes "ValueIterator" and "ValueHandler".

The idea is to make transparent the pagination of a query returning a (very) large amounts of data.

Use and Integration

Configure your POM

Two step

Add repository :

<repositories>
<repository>
<id>intelligents-ia</id>
<name>Intelligents-ia Repository</name>
<url>http://intelligents-ia.com/maven2</url>
</repository>
</repositories>

And dependency :

<dependencies>
<dependency>
<groupId>org.intelligentsia.utility</groupId>
<artifactId>jpa</artifactId>
<version>1.0</version>
</dependency>
</dependencies>

For the curious: Checking Out Source Code Project

This will also allow you to copy and paste the ad hoc files and customize them to your data layer.

svn checkout https://blog-intelligents-ia.googlecode.com/svn/trunk/jpa-utility jpa-utility --username yoursUserName
mvn clean install

The project and the sample

You can see the unit test definition features with "full" data access layer with a first service based on it.

Here is the data model to persist :

1. Creations of the entities and attributes

For entity site :

/**
* Our Site entity.
*
* @author <a href="mailto:jguibert@intelligents-ia.com">Jérôme Guibert</a>
* @version 1.0.0
*/
@Entity
@Table(name = "SITE")
@NamedQueries({
@NamedQuery(name = "selectAllSite", query = "SELECT s FROM Site s")
})
public class Site implements Serializable, TimeStamped {
/**
* serialVersionUID
*/
private static final long serialVersionUID = -1823543375371695270L;
/**
* Automatic version number
*/
@Version
protected Long version;
/**
* Identity with an automatic sequence
*/
@Id
@GeneratedValue(generator = "SEQ_SITE_ID")
@SequenceGenerator(name = "SEQ_SITE_ID", sequenceName = "SEQ_SITE_ID")
@Column(name = "SITE_ID")
private Long id;
/**
* Name of site with an index
*/
@Column(name = "NAME", length = 48, nullable = true)
@Index(name = "SITE_NAME_INDEX", columnNames = {
"NAME"
})
private String name;
...
/**
*  all pages
*/
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = "SITE_ID")
private List<page> pages = new ArrayList<page>();
/**
* Time stamp data embedded in this entity
*/
@Embedded
private TimeStamp timeStamp = new TimeStamp();
...
}

Pour l'entité Page :

/**
* a page included in our site entity
*
* @author <a href="mailto:jguibert@intelligents-ia.com">Jérôme Guibert</a>
* @version 1.0.0
*/
@Entity
@Table(name = "PAGE")
public class Page implements  Serializable, TimeStamped{
private static final long serialVersionUID = -773904423928687747L;
/**
* Automatic version number
*/
@Version
protected Long version;
/**
* Identity with an automatic sequence
*/
@Id
@GeneratedValue(generator = "SEQ_PAGE_ID")
@SequenceGenerator(name = "SEQ_PAGE_ID", sequenceName = "SEQ_PAGE_ID")
@Column(name = "PAGE_ID")
private Long id;
/**
* Name of  page
*/
@Column(name = "NAME", length = 48, nullable = false)
private String name;
/**
* Time stamp data embedded in this entity
*/
@Embedded
private TimeStamp timeStamp = new TimeStamp();
/**
* An example of many to many association
*/
@ManyToMany(cascade = {
CascadeType.PERSIST, CascadeType.MERGE
}, mappedBy = "pages", targetEntity = org.intelligentsia.utility.jpa.model.Tag.class)
private List<tag> tags = new ArrayList<tag>();
...
}

I draw your attention to the statement of the relationship between Site and Page in 1-N. For example, NN between Page and Tag, here is an excerpt of the class "Tag" :

...
/**
* a many to many example.
*/
@ManyToMany(targetEntity = org.intelligentsia.utility.jpa.model.Page.class, cascade =" ""{"
CascadeType.PERSIST, CascadeType.MERGE
})
@JoinTable(name = "TAG_PAGE", joinColumns = @JoinColumn(name = "TAG_ID"), inverseJoinColumns = @JoinColumn(name = "PAGE_ID"))
private List<page> pages = new ArrayList<page>();
...

2.Reporting entities and the file "my-persistence.xml"

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="my-model" transaction-type="RESOURCE_LOCAL">
<description>
Unite du projet
</description>
<class>org.intelligentsia.utility.jpa.model.Page</class>
<class>org.intelligentsia.utility.jpa.model.Site</class>
<class>org.intelligentsia.utility.jpa.model.Tag</class>
<exclude-unlisted-classes />
</persistence-unit>
</persistence>

A little tedious...

3. A pinch of Spring

First statement: The location of properties file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
// Here we specify where to find our property file
<context:property-placeholder location="classpath:META-INF/model.properties" />
<context:annotation-config />

Here, we tell Spring to see what the package contains "org.intelligentsia.utility.jpa" (and its sub-package), and instantiate all that moves ...

	// Where are your service and your class model ?
<context:component-scan base-package="org.intelligentsia.utility.jpa" />

La partie de plaisir : La déclaration de l'entity manager...

<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
<!-- ENTITY MANAGER -->
<bean id="modelEntityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="persistenceUnitName" value="my-model" />
<property name="persistenceXmlLocation" value="classpath:META-INF/my-persistence.xml" />
<property name="dataSource" ref="model-dataSource" />
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="databasePlatform" value="${model.hibernate.dialect}" />
<property name="showSql" value="${model.hibernate.showsql}" />
</bean>
</property>
<property name="jpaPropertyMap">
<map>
<entry key="hibernate.dialect" value="${model.hibernate.dialect}" />
<entry key="hibernate.hbm2ddl.auto" value="${model.hibernate.hbm2ddl.auto}" />
<entry key="hibernate.format_sql" value="${model.hibernate.format_sql}" />
<entry key="hibernate.cache.use_second_level_cache" value="${model.hibernate.cache.use_second_level_cache}" />
<entry key="hibernate.cache.provider_class" value="${model.hibernate.cache.provider_class}" />
<entry key="hibernate.cache.use_query_cache" value="${model.hibernate.cache.use_query_cache}" />
<entry key="hibernate.cache.use_second_level_cache" value="${model.hibernate.cache.use_second_level_cache}" />
<entry key="hibernate.cache.use_structured_cache" value="${model.hibernate.cache.use_structured_cache}" />
<entry key="hibernate.ejb.naming_strategy" value="${model.hibernate.namingStrategy}" />
</map>
</property>
</bean>
<!--  TRANSACTION MANAGEMENT  -->
<bean id="modelTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="modelEntityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="modelTransactionManager" />

Et maintenant, nous pouvons instancier nos Dao, et definir en une ligne la connection à la base de données.

<!-- DAO DECLARATION -->
<bean id="pageDao" class="org.intelligentsia.utility.jpa.GenericJpaDao">
<constructor-arg value="org.intelligentsia.utility.jpa.model.Page" />
</bean>
<bean id="tagDao" class="org.intelligentsia.utility.jpa.GenericJpaDao">
<constructor-arg value="org.intelligentsia.utility.jpa.model.Tag" />
</bean>
<bean id="model-dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.h2.Driver" />
<property name="url" value="jdbc:h2:~/test" />
</bean>
</beans>

4. The properties file to customize to your taste and color

model.hibernate.dialect=org.hibernate.dialect.H2Dialect
model.hibernate.showsql=true
# validate | update | create | create-drop
model.hibernate.hbm2ddl.auto=update
model.hibernate.format_sql=true
model.hibernate.cache.use_second_level_cache=true
model.hibernate.cache.provider_class=org.hibernate.cache.HashtableCacheProvider
model.hibernate.cache.use_query_cache=true
model.hibernate.cache.use_second_level_cache=true
model.hibernate.cache.use_structured_cache=true
#org.hibernate.cfg.DefaultNamingStrategy| org.intelligentsia.utility.jpa.DevTableNamingStrategy
model.hibernate.namingStrategy=org.intelligentsia.utility.jpa.DevTableNamingStrategy

I hope that this can be util you, if you have any questions, comments, please do not hesitate!

Winstone 1.0.2 - conteneur de servlet

Jérôme Guibert — Wed, 15 Feb 2012 11:56:00 +0100

Winstone 1.0.2 est (enfin) disponible

Vous pourrez retrouvez toutes les informations nécessaire à ce projet sur le site de Google Code.

Comment ca marche?

Utiliser directement la ligne de commande après avoir téléchargée l'archive (winstone-1.0.2-boot.jar):

La liste complète de toute les options de la ligne de commande est encore en anglais (si vous insistez vraiment, je vous la traduirais...)

Quelques informations

Support des API Servlet jusqu'à la version 2.5
Documentation JNDI
Options de la ligne de commande
Projet construit via maven et disponible en Open source (LPGL) via Google Code

Bootstrap your application with Keystone

Jérôme Guibert — Wed, 15 Feb 2012 11:05:00 +0100

Everything you need to use the plugin that turns your jar in a standalone archive!

The parameter list of keystone plugin for maven
the XML fragment to integrate into your pom.xml

This project is a bootstrap that loads your application and its dependencies into a single archive. With his maven plugin, its use is very easy!

Configure your pom

<build>
    <plugins>
        <plugin>
            <groupId>org.intelligentsia.keystone</groupId>
            <artifactId>plugin</artifactId>
            <version>2.2</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <configuration>
                        <mainClass>your.class.Main</mainClass>
                    </configuration>
                    <goals>
                        <goal>custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Add plugin and bootstrap repository:

<pluginRepositories>
    <pluginRepository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </pluginRepository>
</pluginRepositories>
<repositories>
    <repository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </repository>
</repositories>

Keystone Maven Plugin Parameters

Name	Comment
mainClass	your class 'Main' which implements: public static void main(String[] args)

cleanUpLib	true \| false (default true), clean up folder named “lib” at startup before extraction of initial archive
cleanUpBeforeShutdown	true \| false (default is false),clean up folder named “lib” at shutdown

info	true \| false (default is false), level 'INFO' logs generated by the Keystone bootsrap
verbose	true \| false (default is false), level ‘VERBOSE’ logs generated by the Keystone bootsrap
logFile	Log file path. Per default, all logs go on standard output.

includeJavaHomeLib	true \| false (default is true), Add to classpath application, archives from the JAVA_HOME / lib if it exists
includeSystemClassLoader	true \| false (default is true).Adding the system classloader as a parent application class loaders

explodeDirectory	Root extracting archives embark with the bootstrap. By default, this directory is the current directory if write operations are allowed on it, otherwise it is a temporary folder that is used.
finalName	Final artifact name. By default, this is the name of the original artefact suffix "-boot". Example for "sample.jar", it will be "sample-boot.jar"
replaceProjectArtifact	true \| false (default is false). If enabled, the archive packaged artifact replaces the current project

That's All
Enjoy

Configuration du plugin maven pour Keystone 2.2

Jérôme Guibert — Tue, 14 Feb 2012 16:59:00 +0100

Tout ce qu'il vous faut pour utiliser de suite le plugin qui transforme votre jar en une archive autonome!

La liste des paramètres du plugin keystone pour maven
le fragment XML à intégrer à votre pom.xml

Liste des paramètres

Nom	Description
mainClass	votre classe “Main” qui implémente la méthode public static void main(String[] args) { … }

cleanUpLib	true\|false (par défaut true) nettoyage du dossier “lib” au démarrage avant l’extraction des librairies contenues dans l’archive initiale
cleanUpBeforeShutdown	true\|false (par défaut false) nettoyage du dossier “lib” à l’arrêt du programme

info	true\|false (par défaut false) niveau ‘INFO’ des logs générés par le bootsrap Keystone
verbose	true\|false (par défaut false) niveau ‘VERBOSE’ des logs générés par le bootsrap Keystone
logFile	chemin d’accès au fichier de log. Par défaut les logs se font sur la sortie standard.

includeJavaHomeLib	true\|false (par défaut true) Ajout au classpath de l’application, des archives issues du répertoire JAVA_HOME/lib si il existe
includeSystemClassLoader	true\|false (par défaut true) Ajout du classloader système en tant que parent au classloader de l’application

explodeDirectory	Répertoire racine d’extraction des archives embarquer avec le bootstrap. Par défaut, ce répertoire est le répertoire courant si les opération d’écritures sont permises sur celui-ci, sinon c’est un dossier temporaire qui est utilisé.
finalName	Nom de l’artefact final Par défaut, c’est le nom de l’artefact original suffixé par “-boot”. Example pour “sample.jar”, cela sera: “sample-boot.jar”
replaceProjectArtifact	true\|false (par défaut false) Si activé, l’archive packagé remplace l’artefact du projet courant

Intégration à votre projet

Ajouter le repository du plugins

<pluginRepositories>
    <pluginRepository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </pluginRepository>
</pluginRepositories>
<repositories>
    <repository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </repository>
</repositories>

Et configurer le build de votre projet avec le plugin "keystone-plugin" (indiquer votre classe de démarrage) :

<build>
    <plugins>
        <plugin>
            <groupId>org.intelligentsia.keystone</groupId>
            <artifactId>plugin</artifactId>
            <version>2.2</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <configuration>
                        <mainClass>votre.class.Main</mainClass>
                    </configuration>
                    <goals>
                        <goal>custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Keystone 2.2 est sortie !

Jérôme Guibert — Thu, 09 Feb 2012 17:18:00 +0100

la version 2.2 de keystone viens de sortir!

Beaucoup de correctif (ce qui explique l’absence de déclaration officiel du parti pour les version 1.4, 1.6, 1...., 2.0, ...

Tout ceci a été rendue possible par l'adoption de ce projet/plugin dans d'autres projets d'entreprise

Bonjour,

la version 2.2 de keystone viens de sortir!

Ce projet est un bootstrap qui embarque votre application et ses dépendances en une seule archive.
Accompagné de son plugin maven, son utilisation est des plus simple!

Cette nouvelle version 2.2 inclus :

des corrections du plugin maven: gestion des paramètre de configuration (niveau de log, localisation du fichier de log, nettoyage des répertoires temporaires, ...)
des correctifs du bootstrap:
- correction de l'extraction des jar
- suppression de warning qui n'en etait pas
- refonte du mécanisme d'arrêt/mise à jour: plus simple et efficace
- ajout de log plus pertinent
- refonte du système de gestion de l'instanciation des classes

Intégration du plugin à votre POM

Ajouter le repository du plugins

<pluginRepositories>
    <pluginRepository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </pluginRepository>
</pluginRepositories>
<repositories>
    <repository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </repository>
</repositories>

Et configurer le build de votre projet avec le plugin "keystone-plugin" (indiquer votre classe de démarrage) :

<build>
    <plugins>
        <plugin>
            <groupId>org.intelligentsia.keystone</groupId>
            <artifactId>plugin</artifactId>
            <version>2.2</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <configuration>
                        <mainClass>votre.class.Main</mainClass>
                    </configuration>
                    <goals>
                        <goal>custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Récupération des sources

Les sources du projets ont été déplacées pour cette occasion.

Pour récupérer le code source et construire le projet (client svn et maven obligatoire) :

svn checkout https://intelligents-ia.googlecode.com/svn/trunk/keystone keystone --username yoursUserName
cd keystone
mvn clean package

La terre vue de l'espace

Jérôme Guibert — Thu, 09 Feb 2012 16:01:00 +0100

Séquences de photographies prises par l'équipage des expéditions 28 & 29 à bord de la Station spatiale internationale d'Août à Octobre 2011.
Altitude d'environ 350 km.

Terre | Prise de vue depuis l'espace | NASA, ISS de Michael König.

Lieux par ordre d'apparition:

Aurore boréale au dessus des Etats-Unis de nuit
Aurore boréale et de l'Est Etats-Unis de nuit
Aurore australe de Madagascar au sud-ouest de l'Australie
Aurore australe sud de l'Australie
Côte nord-ouest des Etats-Unis d'Amérique du Sud centrale de nuit
Aurore boréale du Sud à l'Océan Pacifique Nord
Autre bout du monde
Passage de nuit sur l'Afrique centrale et le Moyen-Orient
Passage de nuit dans le désert du Sahara et du Moyen-Orient
Survol du Canada et des États-Unis à Central Nuit
Survol de la Californie du Sud à la baie d'Hudson
Iles de la Mer des Philippines de nuit
Survol de l'Asie orientale à la mer des Philippines et de Guam
Vues de nuit au Proche-Orient
Survol de nuit de la mer Méditerranée
Aurore boréale et les États-Unis de nuit
Aurore australe dans l'Océan Indien
Europe de l'Est à l'Asie du Sud de nuit

J'adore ces images et en même temps une "petite" chose m'effraie: à quoi bon éclairer l'espace quand on dors ?

Lambda-calcul, type et modèles

Jérôme Guibert — Fri, 11 Nov 2011 17:46:00 +0100

De J.L Krivine aux éditions Masson.

Un auteur qui fait rêver, professeur à l'université Paris-VII, ~krivine.

Krivine est le père du nouveau point de vue sur la théorie, notamment sur les correspondances entre informatique et mathématique.

De J.L Krivine aux éditions Masson.

Un auteur qui fait rêver, professeur à l'université Paris-VII, ~krivine.

Krivine est le père du nouveau point de vue sur la théorie, notamment sur les correspondances entre informatique et mathématique.

Un très bon ouvrage, très complet mais qui n'explique pas assez les conséquences ses travaux à mon goûts, notamment la possible interprétation en psychologie ou en physiologie.

Un livre qui mériterait une réédition avec un appendix dénotant les conséquences philosophiques des recherches de Krivine.

Une mise à jour de ce livre est gratuitement disponible (en anglais) : Lambda-calculus, types and models Ellis Horwood (1993) (mise à jour 3 novembre 2011)

Spécifications algébriques, algorithmique et programmation

Jérôme Guibert — Fri, 11 Nov 2011 17:24:00 +0100

De Jean-François Dufourd, Dominique Bechmann et Yves Bertrand.

Paru en 12/1997

Il a été mon livre de chevet pendant le temps de mes études à la faculté de Dijon, une aide essentiel pour qui veut construire et comprendre l'essence des types et des algorithmes qui jouent avec.

Spécification algébrique, algorithmique et programmation de Jean-François Dufourd, Dominique Bechmann et Yves Bertrand.

Paru en 12/1997

Jean-François Dufourd est professeur d'informatique à l'université Louis-Pasteur de Strasbourg.
Dominique Bechmann et Yves Bertrand y sont respectivement maître de conférences et chargé de recherches CNRS.

Extrait de la quatrième de couverture, car franchement je peux pas dire mieux:

L'ambition de cet ouvrage est de couvrir tout le processus allant de la spécification abstraite d'un problème à sa programmation en proposant des méthodes et outils réalistes et éprouvés.

Il aborde ainsi la spécification des données et opérations, fondée sur les techniques algébriques, fournit des méthodes de transformation rigoureuses, conduisant à des algorithmes sûrs et bien documentés, et montre comment effectuer leur transcription en langage C.

Il étudie en outre de manière systématique, avec des spécifications algébriques, les structures de données de base pour ranger, rechercher, trier des données et gérer un espace mémoire, et introduit les notions liées à la complexité des algorithmes.
De nombreux sujets d'exercices, problèmes et projets complètent la présentation.

L'ouvrage est destiné aux étudiants de licence maîtrise d'informatique, de MIAGE, des IUP d'informatique et des écoles d'ingénieurs.
Il sera aussi utile aux étudiants de DESS et aux développeurs de logiciel.

Sommaire

Construction de programmes
Spécifications algébriques : le cas équationnel pur
Spécifications algébriques : le cas général
Implantation et programmation
Spécifications étendues
Piles, files et listes linéaires
Suppression de la récursivité
Complexité et optimalité
Tables
Graphes : spécification et implantation
Graphes : algorithmes classiques
Arbres et forêts : spécification et implantation
Arbres et forêts : algorithmes et variétés d'arbres
tris internes
Fichiers
Tris externes.

Quand je vous disais que c'était la base... Lisez Le !!

Keystone 1.4 est sortie !

Jérôme Guibert — Fri, 11 Nov 2011 15:56:00 +0100

Bonjour,

la version 1.4 de keystone viens de sortir!

Pour rappel, ce projet est un bootstrap qui embarque votre application et ses dépendances en une seule archive.
Accompagné de son plugin maven, son utilisation est des plus simple!

Bonjour,

la version 1.4 de keystone viens de sortir!

Pour rappel, ce projet est un bootstrap qui embarque votre application et ses dépendances en une seule archive.
Accompagné de son plugin maven, son utilisation est des plus simple!

Cette nouvelle version 1.4 inclus :

des corrections du plugin maven:
- Le plugin ajoute un nouvel artifact au projet. Son Identifiant devient celui de votre projet suffixé par "-boot"
- les dépendances de scope compile et runtime sont désormais incluses
- les dépendances transitives sont désormais gérées (bug corrigé depuis la version 1.3)
des correctifs du bootstrap:
- les paramètres passé en lignes de commande sont désormais correctement redonner à la classe cible
- si le dossier d'extraction des archives n'a pas les droits d'écriture, les archives java seront extraites dans un dossier temporaires géré par la jvm
des évolutions autour des artifacts du projets:
- ajout d'un artifact contenant les sources au projet "org.intelligentsia.keystone:boot" de façon à faciliter son utilisation avancée
- ajout d'un artifact contenant la javadoc
- les artifacts en "release" sont désormais signés

Intégration du plugin à votre POM

Ajouter le repository du plugins

<pluginRepositories>
    <pluginRepository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </pluginRepository>
</pluginRepositories>
<repositories>
    <repository>
        <id>intelligents-ia</id>
        <name>Intelligents-ia Repository</name>
        <url>http://intelligents-ia.com/maven2</url>
    </repository>
</repositories>

Et configurer le build de votre projet avec le plugin "keystone-plugin" (indiquer votre classe de démarrage) :

<build>
    <plugins>
        <plugin>
            <groupId>org.intelligentsia.keystone</groupId>
            <artifactId>plugin</artifactId>
            <version>1.4</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <configuration>
                        <mainClass>votre.class.Main</mainClass>
                    </configuration>
                    <goals>
                        <goal>custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Récupération des sources

Les sources du projets ont été déplacées pour cette occasion.

Pour récupérer le code source et construire le projet (client svn et maven obligatoire) :

svn checkout https://intelligents-ia.googlecode.com/svn/trunk/keystone keystone --username yoursUserName
cd keystone
mvn clean package

Intéressé par la robotique ?

Jérôme Guibert — Fri, 27 May 2011 12:53:00 +0200

Vous vous dites que “flasher la rom du pic” c’est comme de la tarte au chocolat fourée à la moutarde ? Bonne nouvelle, vous pouvez utiliser Android comme base de votre futur Robot !

Vous vous dites que “flasher la rom du pic” c’est comme de la tarte au chocolat fourée à la moutarde ?
Bonne nouvelle, vous pouvez utiliser Android comme base de votre futur Robot !

Il y a IOIO (prononcé yo-yo) un projet qui vous permet de connecter votre téléphone sous android à vos périphériques favoris.

De cette manière vous bénéficié de l’environnement Java pour vos création :-)

Vous n’aurez plus aucune excuse pour ne pas transpirez des neurones.

Et si vous voulez aller un peu plus loin, aller donc faire un tour sur ce projet ROS (projet sous google code)

Gestion des transactions Spring JPA

Jérôme Guibert — Fri, 27 May 2011 11:03:00 +0200

Comment gérer les transactions quand on utilise Spring et JPA ?

Ce n'est pas bien compliqué.... ou presque.

Comment gérer les transactions quand on utilise Spring et JPA ?

Ce n'est pas bien compliqué.... ou presque.

Il nous faut tout d'abord un projet avec des objets persités en base de données, quelques dao et les services d'interrogation ad hoc. Pour cela je vous propose de repartir du projet java de ce billet : "How to : JPA, Hibernate & Co".

Si vous avez déjà lu ce billet, vous pouvez passer directement au chapitre suivant.

Presentation du projet

Voici le modèle de données de ce projet :

1. Créations des entitées et attributs

Pour l'entité site :

/**
* Our Site entity.
*
* @author <a href="mailto:jguibert@intelligents-ia.com">Jérôme Guibert</a>
* @version 1.0.0
*/
@Entity
@Table(name = "SITE")
@NamedQueries({
@NamedQuery(name = "selectAllSite", query = "SELECT s FROM Site s")
})
public class Site implements Serializable, TimeStamped {
/**
* serialVersionUID
*/
private static final long serialVersionUID = -1823543375371695270L;
/**
* Automatic version number
*/
@Version
protected Long version;
/**
* Identity with an automatic sequence
*/
@Id
@GeneratedValue(generator = "SEQ_SITE_ID")
@SequenceGenerator(name = "SEQ_SITE_ID", sequenceName = "SEQ_SITE_ID")
@Column(name = "SITE_ID")
private Long id;
/**
* Name of site with an index
*/
@Column(name = "NAME", length = 48, nullable = true)
@Index(name = "SITE_NAME_INDEX", columnNames = {
"NAME"
})
private String name;
...
/**
*  all pages
*/
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = "SITE_ID")
private List<page> pages = new ArrayList<page>();
/**
* Time stamp data embedded in this entity
*/
@Embedded
private TimeStamp timeStamp = new TimeStamp();
...
}

Pour l'entité Page :

/**
* a page included in our site entity
*
* @author <a href="mailto:jguibert@intelligents-ia.com">Jérôme Guibert</a>
* @version 1.0.0
*/
@Entity
@Table(name = "PAGE")
public class Page implements  Serializable, TimeStamped{
private static final long serialVersionUID = -773904423928687747L;
/**
* Automatic version number
*/
@Version
protected Long version;
/**
* Identity with an automatic sequence
*/
@Id
@GeneratedValue(generator = "SEQ_PAGE_ID")
@SequenceGenerator(name = "SEQ_PAGE_ID", sequenceName = "SEQ_PAGE_ID")
@Column(name = "PAGE_ID")
private Long id;
/**
* Name of  page
*/
@Column(name = "NAME", length = 48, nullable = false)
private String name;
/**
* Time stamp data embedded in this entity
*/
@Embedded
private TimeStamp timeStamp = new TimeStamp();
/**
* An example of many to many association
*/
@ManyToMany(cascade = {
CascadeType.PERSIST, CascadeType.MERGE
}, mappedBy = "pages", targetEntity = org.intelligentsia.utility.jpa.model.Tag.class)
private List<tag> tags = new ArrayList<tag>();
...
}

2. Configuration du fichier "my-persistence.xml"

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="my-model" transaction-type="RESOURCE_LOCAL">
<description>
Unite du projet
</description>
<class>org.intelligentsia.utility.jpa.model.Page</class>
<class>org.intelligentsia.utility.jpa.model.Site</class>
<class>org.intelligentsia.utility.jpa.model.Tag</class>
<exclude-unlisted-classes />
</persistence-unit>
</persistence>

3. Configuration Spring

La localisation du fichier de propriétées

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
// Here we specify where to find our property file
<context:property-placeholder location="classpath:META-INF/model.properties" />
<context:annotation-config />

Instanciation des objets du package "org.intelligentsia.utility.jpa" (et ses sous-package)

	// Where are your service and your class model ?
<context:component-scan base-package="org.intelligentsia.utility.jpa" />

Déclaration de l'entity manager...

<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
<!-- ENTITY MANAGER -->
<bean id="modelEntityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="persistenceUnitName" value="my-model" />
<property name="persistenceXmlLocation" value="classpath:META-INF/my-persistence.xml" />
<property name="dataSource" ref="model-dataSource" />
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="databasePlatform" value="${model.hibernate.dialect}" />
<property name="showSql" value="${model.hibernate.showsql}" />
</bean>
</property>
<property name="jpaPropertyMap">
<map>
<entry key="hibernate.dialect" value="${model.hibernate.dialect}" />
<entry key="hibernate.hbm2ddl.auto" value="${model.hibernate.hbm2ddl.auto}" />
<entry key="hibernate.format_sql" value="${model.hibernate.format_sql}" />
<entry key="hibernate.cache.use_second_level_cache" value="${model.hibernate.cache.use_second_level_cache}" />
<entry key="hibernate.cache.provider_class" value="${model.hibernate.cache.provider_class}" />
<entry key="hibernate.cache.use_query_cache" value="${model.hibernate.cache.use_query_cache}" />
<entry key="hibernate.cache.use_second_level_cache" value="${model.hibernate.cache.use_second_level_cache}" />
<entry key="hibernate.cache.use_structured_cache" value="${model.hibernate.cache.use_structured_cache}" />
<entry key="hibernate.ejb.naming_strategy" value="${model.hibernate.namingStrategy}" />
</map>
</property>
</bean>
<!--  TRANSACTION MANAGEMENT  -->
<bean id="modelTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="modelEntityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="modelTransactionManager" />

Instanciation de nos Dao, et definission de la connection à la base de données.

<!-- DAO DECLARATION -->
<bean id="pageDao" class="org.intelligentsia.utility.jpa.GenericJpaDao">
<constructor-arg value="org.intelligentsia.utility.jpa.model.Page" />
</bean>
<bean id="tagDao" class="org.intelligentsia.utility.jpa.GenericJpaDao">
<constructor-arg value="org.intelligentsia.utility.jpa.model.Tag" />
</bean>
<bean id="model-dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.h2.Driver" />
<property name="url" value="jdbc:h2:~/test" />
</bean>
</beans>

4. Le fichier de propriétés

model.hibernate.dialect=org.hibernate.dialect.H2Dialect
model.hibernate.showsql=true
# validate | update | create | create-drop
model.hibernate.hbm2ddl.auto=update
model.hibernate.format_sql=true
model.hibernate.cache.use_second_level_cache=true
model.hibernate.cache.provider_class=org.hibernate.cache.HashtableCacheProvider
model.hibernate.cache.use_query_cache=true
model.hibernate.cache.use_second_level_cache=true
model.hibernate.cache.use_structured_cache=true
#org.hibernate.cfg.DefaultNamingStrategy| org.intelligentsia.utility.jpa.DevTableNamingStrategy
model.hibernate.namingStrategy=org.intelligentsia.utility.jpa.DevTableNamingStrategy

Gestion des transactions

Transaction Manager

Apres avoir déclarée notre "entity manager factory", nous avons besoin d'un gestionnaire de transaction. Cela ce déclare comme suit :

<!--  TRANSACTION MANAGEMENT  -->
<bean id="modelTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="modelEntityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="modelTransactionManager" />

Nous spécifions à Spring que nous allons configurer les transaction via des annotations.

Déclaration des services transactionels

La classe "GenericJpaDao" mère de nos autres DAO, ne déclare pas d'attribut de transaction. Ceci vous oblige à spécifier où et comment une transactions doit commencer.

Ma méthode est la suivante :

Ajout du support des transactions (en lecture seulement) au service
Ajout du support des transactions en écriture pour les méthodes qui en ont besoin

Concrétement pour impleménter le service :

public interface BlogService {
public void createBlog(final String name);
public Iterable<Site> findAllSite();
}

Cela donne :

@Service("blogService")
@Scope(BeanDefinition.SCOPE_SINGLETON)
@Transactional(readOnly = true, propagation = Propagation.REQUIRED)
public class BlogServiceImpl implements BlogService {
@Autowired
private SiteDao siteDao;
@Autowired
private GenericJpaDao<Page, Long> pageDao;
@Autowired
private GenericJpaDao<Tag, Long> tagDao;
@Override
@Transactional(readOnly = false)
public void createBlog(final String name) {
/**
* Create a new site
*/
Site site = new Site();
site.setName(name);
siteDao.persist(site);
/**
* Add a default page
*/
Page page = new Page();
page.setName("home page");
pageDao.persist(page);
// associate
site.getPages().add(page);
siteDao.persist(site);
}
@Override
public Iterable<Site> findAllSite() {
return siteDao.findAll();
}
}

La méthode "findAllSite" est bien en lecture seule, alors que "createBlog" doit pouvoir supporter l'écriture

Et c'est tout!

Bien évidement, pour aller un peu plus loin dans la configuration et la gestion des transactions au sein de Spring, je vous invite à consulter la documentation à ce sujet.

Configuration de Maven

Jérôme Guibert — Tue, 24 May 2011 11:49:00 +0200

Récemment, j'ai du ré-installer plusieurs environnement de développement, et je voulais partager avec vous ce petit guide de configuration de maven.
Car si l'installation est des plus simple, la configuration l'est beaucoup moins.

EnglishVersion

Sous ubuntu, l'installation se résume à :

sudo apt-get install maven2

Les fichiers sont installés dans le dossier /usr/share/maven2 et la configuration dans /etc/maven2.

Sous windows, télécharger une archive de maven et dézippé la sous c:\maven2. Vous pouvez trouver cela sur Apache

Les fichiers sont installés dans le dossier c:\maven2 et la configuration dansc:\maven2\conf.

Toujours sous Windows, v&eactue;rifiez que vous avez bien les variables d'environnement: (echo %NOM_VARIABLE%)

JAVA_HOME: qui pointe vers un JDK et pas un JRE
M2_HOME: qui pointe sur "c:\maven2"
un PATH qui contient "c:\maven2\bin"

Si ce n'est pas le cas, positionnez ces valeurs, ouvrez un nouveaux terminal, testez.

Création du repository local

Création du dossier dans /usr/local/m2-repository/ (ou c:\maven2\m2-repository) et on positionne les droits d'écriture pour tous le monde.

C'est dans ce dossier que l'ensemble des libraries vont être copiée, selon les besoins de vos projets.

cd /usr/local
sudo mkdir m2-repository
sudo chmod a+w  m2-repository/

Configuration minimal

Edition du fichier de configuraton "settings.xml", pour indiquer où se trouve le repository local et quel miroir utiliser.

(Le repository officiel de maven est "http://repo1.maven.org/", afin d'avoir des temps de réponse raisonnable nous utilisons un miroir)

<!-- local repository diractory -->
<localRepository>/usr/local/m2-repository</localRepository>
<mirrors>
<mirror>
<id>UK</id>
<name>UK Central</name>
<url>http://uk.maven.org/maven2</url>
<mirrorOf>central, maven-central-repository</mirrorOf>
</mirror>
</mirrors>

Vérification de l'installation

On saisie:

mvn -version

Et cela devrait vous donner quelque chose comme cela:

Apache Maven 2.2.1 (r801777; 2009-08-06 21:16:01+0200)
Java version: 1.6.0_17
Java home: /usr/local/jdk1.6.0_17/jre
Default locale: fr_FR, platform encoding: UTF-8
OS name: "linux" version: "2.6.32-24-generic-pae" arch: "i386" Family: "unix"

A partir de ce moment, vous avez un système maven opérationnel.

Je vous propose d'aller un tout petit peu plus loin avec les repository de façon à vous faire gagner beaucoup de temps.

Les Repository à connaître

L'idéal avec maven et d'utiliser un repository local type nexus/archiva qui va tenir lieu de miroir à tous les repository maven disséminés sur Internet.
Dans votre fichier settings.xml, vous aurez une configuration qui ressemble à cela :

 <mirrors>
<mirror>
<id>internal-repository</id>
<name>Maven Repository Manager running on repo.mycompany.com</name>
<url>http://repo.mycompany.com/proxy</url>
<mirrorOf>*</mirrorOf>
</mirror>
</mirrors>

Ici, l'url "repo.mycompany.com" est l'url du repository de votre compagnie.

Comme l'installation d'un mirroir n'est pas toujours possible, ni même souhaité, voici un autre moyen de rajouter artificiellement une liste de repository à vos projets.

L'idée est de créér un profile dans le fichier settings qui va lister l'ensemble des repository que vous souhaiter avoir par défaut dans vos projets. Ennsuite vous aurez le choix de l'activer par défaut ou à la demande.

      <profiles>
<profile>
<id>my-repository</id>
<activation>
<!-- here we did not activate this profile by default -->
<activeByDefault>false</activeByDefault>
</activation>
<repositories>
<!-- list of standard repository -->
...
</repositories>
</profile>
</profiles>

Pour lancer un commande maven utilisant cette liste de repository, vous devrez rajouter "-Pmy-repository" comme parametre (car le profil n'est pas activé par défaut):

mvn -Pmy-repository clean install

Maintenant, voici une petite liste de repository bien utile:

<repository>
<id>javanet</id>
<name>Repository for Maven2</name>
<url>http://download.java.net/maven/2</url>
</repository>
<repository>
<id>google</id>
<name>Google repository for Maven2</name>
<url>https://oss.sonatype.org/content/repositories/google-releases/</url>
</repository>
<repository>
<id>jboss</id>
<name>JBoss repository for Maven2</name>
<url>http://repository.jboss.org/maven2/</url>
</repository>
<repository>
<id>com.springsource.repository.bundles.release</id>
<name>SpringSource Enterprise Bundle Repository - SpringSource Bundle Releases</name>
<url>http://repository.springsource.com/maven/bundles/release</url>
</repository>
<repository>
<id>com.springsource.repository.bundles.external</id>
<name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>
<url>http://repository.springsource.com/maven/bundles/external</url>
</repository>
<repository>
<id>com.springsource.repository.libraries.release</id>
<name>SpringSource Enterprise Bundle Repository - SpringSource Library Releases</name>
<url>http://repository.springsource.com/maven/libraries/release</url>
</repository>
<repository>
<id>com.springsource.repository.libraries.external</id>
<name>SpringSource Enterprise Bundle Repository - External Library Releases</name>
<url>http://repository.springsource.com/maven/libraries/external</url>
</repository>
<repository>
<id>intelligents-ia</id>
<name>Intelligents-ia Repository</name>
<url>http://intelligents-ia.com/maven2</url>
</repository>

Vous pourrez trouver en pièce jointe à ce billet, le fichier settings.xml déjà configuré

Si vous connaissez d'autre repository qu'il serait intéressant de rajouter, n'hésitez pas à me contacter :-)