Intelligents-ia

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.

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.

Création du repository local

Création du dossier dans /usr/local/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)

<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 :-)

Partage et gestion de fichiers en ligne

Jérôme Guibert — Thu, 19 May 2011 12:48:00 +0200

Partagez-vous des documents en ligne ?

Vous connaissez surement "DropBox" et "Google Document". Cependant, mettre des données confidentielles, voir très confidentielles sur ce type de structure est de mon point de vue pas recommandé.
Le projet Mollify est peut être fait pour vous...

Partagez-vous des documents en ligne ?

Vous connaissez surement et . Cependant, mettre des données confidentielles, voir très confidentielles sur ce type de structure est de mon point de vue pas recommandé. De plus si la confidentialité est essentiel pour vous, l'usage d'une solution Internet est-elle vraiment nécessaire ?

Je cherchais une solution qui me permette le partage et la gestion de fichier en ligne, mais surtout installable sur un serveur dans lequel je peux suffisamment avoir confiance par rapport a mon degrés de confidentialité.

Au niveau partage et gestion de fichier en ligne, j'attends:

une gestion simple des comptes utilisateurs, des dossiers, des fichiers
un intégration simple avec différents type de client (Mac, Windows, iPhone, Android),
un mécanisme de prévisualisation,
une solution simple, ne nécessitant pas de connaissances techniques particulières (pas de client FTP/SFTP sinon j'aurais installé un serveur ftp/ssh... ),

Au niveau qualité de la solution:

installable sur un serveur dédié,
une technologie orienté open source,
une solution php ou java (dépendant de ma contrainte serveur, celle-ci sera basé sur php)
un projet bien documenté avec une petite communauté active,

Comment ça, je cherche le mouton à cinq pattes ?

Au fil de mes errances j'ai trouvé ce projet open source : mollify, dont voici quelques vue écran dans le style Mac.

J'ai trouvé cela jolie et efficace rien qu'en visualisant les images, et vous ?

Installation et configuration

L'installation est simple un zip a télécharger.

Pour que cela fonctionne bien, idéalement il vous faut une version php >= 5.2.
Pour la configuration du système je vous conseil d'utiliser le choix "base de donnée", car la configuration via le système de fichier (étant très contraignante) va disparaître dans les prochaine version.

J'ai d'abord installer la chose sous Windows Seven 64 avec le projet http://www.uwamp.com/ (suite a la lecture de notre ami Korben).
Uwamp est excellent! Il s'installe sans aucun soucis. Je le recommande vivement en tant que remplaçant d'EasyPhp, Wamp & Co.

Après l'avoir vu fonctionné, suivi le processus graphique d'installation qui est vraiment confortable, je l'ai vite déployé sur mon petit serveur sous linux (Cela fonctionne très bien aussi sous linux du moment que vous installer apache et ses modules php, avec un mysql).

Pour ce qui est de la communauté, je peux vous dire qu'elle est très réactive! J'ai pu corriger un (tout petit) petit bug sur la configuration par système de fichier et dès le lendemain, cela a été pris en compte. Si vous voulez constater par vous même, je vous invite a aller voir le suivi d'activité de ce projet sur google code.

En ce moment mollify est en version 1.8, vous pouvez le télécharger ici.
Si vous jouez avec, venez me faire un petit retour, ça serait très sympa.

Keystone 1.1 est sortie !

Jérôme Guibert — Fri, 29 Apr 2011 13:06:00 +0200

Bonjour,

cette nouvelle version inclus :

évolution du plugin maven : Le plugin ajoute un nouvel artifact au projet. Son Identifiant devient celui de votre projet suffixé par "-boot",
ajout du packaging des sources au projet "org.intelligentsia.keystone:boot" de façon à faciliter son utilisation avancée

Bonjour,

cette nouvelle version inclus :

évolution du plugin maven : Le plugin ajoute un nouvel artifact au projet. Son Identifiant devient celui de votre projet suffixé par "-boot",
ajout du packaging des sources au projet "org.intelligentsia.keystone:boot" de façon à faciliter son utilisation avancée

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.1</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>

How to : JPA, Hibernate & Co

Jérôme Guibert — Thu, 28 Apr 2011 16:51:00 +0200

Pour être directement opérationnel avec les systèmes de persistance, créer sa couche de donnée et d'accès en suivant les bonnes pratiques du moment, je vous propose dans un seul jar : une DAO générique, une gestion automatique des données temporelle, et une instanciation de JPA/Hibernate/Springframework avec gestion des transactions, le tout en se basant le plus possible sur les annotations.
Ce Billet fait suite à 'parcourir de gros volume de donnée en deux lignes de code'. :)

Introduction

Pour être directement opérationnel avec les systèmes de persistance, créer sa couche de données et d'accès en suivant les bonnes pratiques du moment, je vous propose dans un seul jar :

une DAO générique,
une gestion automatique des données temporelle,
une instanciation de JPA/Hibernate/Springframework avec gestion des transactions,
un configuration du model basé sur les annotations
un exemple complet d'utilisation

Ce Billet fait suite à 'parcourir de gros volume de donnée en deux lignes de code'.

JPA-Utility, what else ?

Dans cette librairie, vous pourrez trouver des utilitaires destinés à nous simplifier l'usage du trio JPA/Hibernate/Spring, comme une DAO générique, des méthodes de parcours de gros volume de données efficace (le système de pagination est intégré), une base pour personnaliser les noms de vos tables en base de données, un mécanisme de datation (pas au carbone 14...) de vos entités, mais surtout un exemple complet et fonctionnel d'une couche de persistence à repomper litérallement pour que vous soyez opérationnel très rapidement.

Une DAO suffit, ... pour commencer

Vous pourrez trouver la classe "org.intelligentsia.utility.jpa.GenericJpaDao" :

C'est une classe paramétrée par le type d'entité gérée 'T' et le type de la clé primaire utilisée 'ID'. Avec ce paramètrage, elle expose :

les méthodes classique : 'persist', 'delete'
une méthode de sélection par clé primaire 'findById'.
un ensemble de méthode 'findByNamedQuery' qui execute une requête, paramétrée ou non, avec un mécanisme de pagination (ou sans) qui vous permet de parcourir de gros volume de donnée avec une boucle 'for' (voir le billet Parcourir de gros volume de données en 2 lignes de code)

Un petit exemple d'utilisation classique :

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

Le parcours d'une collection se résumant à :

@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
	}
...

Lorsque que vous commencer votre projet, je vous invite à ne pas créer de classe spécifique pour chaque entité et de vous forcer à utiliser une instanciation via Spring.
Vous pourrez par la suite, au fur et à mesure des besoins de vos services, rajouter uniquement les requêtes nécessaire sur vos entités.
A ce moment, vous rajouterez les méthodes ad hoc sur une DAO spécifique.

Easter Eggs, un aperçu

La librairie inclus aussi deux ou trois petites choses:

Entity Stamped

Tout d'abord l'interface "TimeStamped" et son compagnon le bean "TimeStamp" vont vous permettre de gérer sur vos entités les champs classiques "timestamp", "creationDate" et "lastModificationDate" de cette manière :

@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;
	}
...

Et c'est tout ! La classe GenericJpaDao va gérer le reste pour vous. Pour les curieux, ce mécanisme repose sur la déclaration d'une interface "TimeStamped", de son bean "TimeStamp" et d'un petit test dans l'implémentation de la méthode "persist" sur "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;
	}
...
}

Réalisé à peu de frais, jusqu'à présent ce test n'a pas été remis en cause par ses performances. Si vous voulez rajouter d'autre fonctionnalité de ce type (tracer qui à fait quoi par exemple, ....) je vous invite à étendre la classe GenericJpaDao ou sinon me proposer l'extension (Je serais ravis de l'intégrer au projet).

Le DBA sera (de nouveau) votre meilleur ami (ou presque)

Trop longtemps maltraité, souvent relégué en bout de chaîne, ils peuvent aussi vous aider (si si, mais pas tous...).

Plutôt que faire comme si il n'existait pas, allez le voir en lui disant que :

Vous allez créér un nouveau schéma (il sera content de l'apprendre au moins un jour avant la mise en production (vécu...) )
Que vous pouvez normaliser le nom des tables que vous allez créer (préfixe, suffixe)
Que vous pouvez nommer les tables 'comme y faut' (voir le "@Table(name = 'PAGE')" en début de chaque déclaration d'entité)

Et si, en plus vous lui montrer un ébauche du schéma qui sera créer plus tard (en local sur votre machine vous devriez avoir ce qu'il faut) ...

De cette façon, le jour (qui n'arriveras jamais ...) où vous serez en panne sèche sur une requête, que vos performances en lecture/écriture seront des plus lamentables, vous pourrez lui demander (très humblement) son aide (précieuse) ...

Pour fixer-le-prefixe-du-suffixe, voilà un petit exemple :

Créez une classe étendant "CustomTableNamingStrategy" et definissez les prefix/suffix de vos 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);
	}
}

Positionnez la valeur de la propriété "model.hibernate.namingStrategy" sur la bonne classe: "model.hibernate.namingStrategy=org.intelligentsia.utility.jpa.DevTableNamingStrategy" (Dans l'example fournit, elle va alimenter le paramètre "hibernate.ejb.naming_strategy").

Le parcours de gros volume de données

Je vous invite à lire le billet Parcourir de gros volume de données en 2 lignes de code. C'est la raison de l'existence des classes "ValueIterator" et "ValueHandler".

L'idée est de rendre transparent la pagination d'une requête retournant un (très) gros volume de données.

Utilisation et Intégration

Configurer votre POM

En deux étapes

Ajouter le "repository" :

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

Et la dépendance suivante :

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

Pour les curieux: Récupération du code source projet

Cela vous permettra aussi de copier-coller les fichiers ad hoc et de les personnaliser à votre couche de données.

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

Le projet et l'exemple type

Vous pourrez voir que le test unitaire embarque un définission "complète" d'une couche d'accès aux données avec un premier service se basant dessus.

Voici le modèle de données à rendre persistant :

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>();
	...
}

J'attire votre attention sur la déclaration du liens entre Site et Page en 1-N. Pour un exemple en N-N entre Page et Tag, voici un extrait de la 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. Déclaration des entités et le 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>

Un peu fastidieux...

3. Une pincée de Spring

Première déclaration :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 />

Ici, nous disons à Spring d'aller voir ce que contient le package "org.intelligentsia.utility.jpa" (et ses sous-package), et d'instancier tous ce qui bouge...

	// 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. Le fichier de propriétés à personaliser selon vos goûts et couleur

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

J'espère que cela pourra vous être util, si vous avez des questions, remarques, surtout n'hésitez pas!

Premier pas avec Clojure

Jérôme Guibert — Thu, 21 Apr 2011 18:17:00 +0200

Pour ceux et celles qui n'ont pas encore franchi le pas, je vous propose un lien vers une petite présentation du langage Clojure que je trouve très pédagogique:Premiers Pas Avec Clojure.

Bonne lecture

Pour ceux et celles qui n'ont pas encore franchi le pas, je vous propose un lien vers une petite présentation du langage Clojure que je trouve très pédagogique:Premiers Pas Avec Clojure.

Bonne lecture

Winstone 1.0 est sortie !

Jérôme Guibert — Fri, 15 Apr 2011 12:46:00 +0200

Aujourd'hui est un grand jour !

Winstone 1.0 est tout juste sortie du four et se dote d'un petit repository maven!!

Aujourd'hui est un grand jour !

Winstone 1.0 est tout juste sortie du four et se dote d'un petit repository maven!!

Vous pouvez donc intégrer ce projet avec la dépendance suivante :

Ou l'utiliser directement en ligne de commande après avoir téléchargée l'archive:

Lancement

N'hésitez pas a me donner vos retours sur l'utilisation

Keystone 1.0 est sortie !

Jérôme Guibert — Fri, 15 Apr 2011 12:13:00 +0200

Keystone version 1.0 est disponible dans votre bonne vieille librairie !

Après une courte scèance d'intégration au projet winstone, et l'ajout d'un paramètre qui-vas-bien au plugin maven keystone, et hop hop hop !

C'est que j'en serais pas peu fier té

Quand je serais grand

Jérôme Guibert — Thu, 14 Apr 2011 15:38:00 +0200

Chute libre au fond de l'eau, ça décoiffe

Comme dis frederic, ça décoiffe!!

How to bootstrap with Keystone

Jérôme Guibert — Wed, 13 Apr 2011 17:03:00 +0200

Embarquer votre applicatif avec ses dépendances dans un seul jar, la déployer, préparer le classpath, s'occuper des options de démarrages, et vous permettre d'automatiser vos mises à jour: Voilà ce que vous propose le projet keystone !

En bref, il va vous simplifier les démarrages ...
Il manquait juste un "petit" plugin maven de manière à le rendre utilisable par tous et quelques lignes, c'est chose faites !

Configurer votre POM

En deux étapes

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

Si votre projet construit une archive "example.jar", le plugin va créer une autre archive "example.boot.jar" (Celle-ci contiendra les dépendances "runtime" et "compile" de votre projet maven).
La ligne de commande nécessaire pour lancer votre application sera :

Options du plugin

Nom	Description
mainClass	java main class

haltOnError	true\|false (par défaut : true), si vrai le système s'arrête à la première erreur, sinon il continue comme il peut (utile lors de mise à jour "tendue")

explode	true\|false (par défaut : true), si vrai, l'archive va être extraite dans le répertoire de démarrage (les répertoires "lib", "tools", et "plugins" vont être alimenté avec les ressources de l'archive de départ)

cleanUpTools	true\|false (par défaut : false), si vrai le répertoire 'tools' va être nettoyer au démarrage du système
cleanUpLib	true\|false (par défaut : true), si vrai le répertoire 'lib' va être nettoyer au démarrage du système
cleanUpPlugins	true\|false (par défaut : false), si vrai le répertoire 'plugins' va être nettoyer au démarrage du système

verbose	true\|false (par défaut : false), active le mode de log 'verbose'
info	true\|false (par défaut : true), active le mode de log 'info'
logFile	fichier de log du bootstrap (par défaut : aucun)

includeJavaHomeLib	true\|false (par défaut : false), inclus le répertoire de librairies du jdk dans le classpath
includeSystemClassLoader	true\|false (par défaut : false), inclus le classloader système dans le classpath
includePlugins	true\|false (par défaut : true), inclus le répertoire des plugins dans le classpath

replaceProjectArtifact	true\|false (par défaut : false), remplace (ou pas) l'archive principal de votre projet par celle "bootable". Si vous la remplacer et que vous avez des projets qui dépendent de cette archive, ceux-ci ne verront pas votre archive projet mais celle bootable, et donc n'auront pas accès à votre code. (vécu avec le projet winstone au niveau des test unitaire du serveur qui utilisent les classes internes de celui-ci)

N'hésitez pas à me contacter et me donner vos retours sur son usage (bon ou mauvais )

Keystone : Bootstraping & Update

Jérôme Guibert — Wed, 06 Apr 2011 18:08:00 +0200

Un petit projet : keystone

Kezaco ?

keystone ou en français "clé de voute" à deux signification : Pierre en forme de coin qui maintient une voûte, Elément central dont tout dépend.

C'est un petit projet java qui est naît de la reprise de Winstone. Lors du refactoring, il est devenue important et nécessaire de simplifier le démarrage de ce serveur et de pouvoir embarquer facilement d'autre librairie dont le serveur dépend (comme une bonne API de log par exemple ...).
C'est comme ça que "keystone" est apparu, avec un petit clin d'oeil a "win" ou "stone" selon l'humeur du jour.

Amorce & Bootsrapping

Le bootstrapping est censé faire référence aux aventures du baron de Münchhausen, lequel se serait sorti d'un marécage où il était embourbé rien qu'en se tirant par les cheveux (plus précisément, sa queue de cheval) et se propulsant ainsi dans les airs. (source : http://fr.wikipedia.org/wiki/Bootstrap). En ce qui nous concerne c'est surtout un petit programme d'amorce.
Pour ceux qui ne connaisse pas du tout, je vous renvoie sur wikipedia.

Le principal intérêt pour nous c'est d'isoler les "classloader" de chaque partie applicative.
Pour ce faire je me suis inspirer de cet article qui vous donne les bases http://blog.markturansky.com/archives/21.

Mise à jour & Update

Le "plus" de ce projet, est la possibilité de mettre à jour de façon automatique votre application/serveur.
Connaissez vous le projet jdownloader ? C'est ce système de mise à jour que je vous propose : un site distant liste les mises à jour disponibles, et votre applicatif décide du "quand" (et même du "comment" si vous plongez un peu plus dans cette mécanique).
Les difficultés autour de cette fonctionnalité proviennent du fait que vous ne pouvez écrasez un "jar" qui est utilisé (il y a un verrou système sur ce fichier).
Ce qui implique de libérer les "jar" en cours d'utilisation avant de les mettre à jour. Nous avons donc besoin d'un petit utilitaire distinct de l'application principale, qui s'occupe de cette mise à jour.

Récupération depuis les sources

Récupération du code source et construction (client svn et maven obligatoire) :

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

Le projet se découpe en quatre partie :

le bootloader : keystone-boot,
une micro API de mise à jour : keystone-api,
l'utilitaire de mise à jour : keystone-update,
un exemple : keystone-sample,
un plugin maven pour que le build soit transparent : keystone-plugin

L'arborescence d'un projet

Lorsque que vous packagez votre application, vous allez obtenir une seule archive (jar). Celle-ci va contenir les dépendances de votre projet, les classes du "bootstrap", la configuration du boot, etc ...

Au démarrage cette archive va être extraite sur le système de fichier, en suivant cette arborescence (${home} étant le répertoire de démarrage) :

"${home}/lib" les dépendances de votre projet ainsi que l'archive de votre application,
"${home}/plugins" toutes les librairies qui peuvent être ajoutées de façon externe (manuellement, jar inclus dans un autre, téléchargement applicatif, ...),
"${home}/tools" les utilitaires comme l'"updater" (ce répértoire permet de façon simple la mise à jour du système)

Les options de démarrage

Voici la liste des option que vous pouvez passer au "Bootstrap" via la ligne de commande ( sous la forme "--name=value" ) ou par un fichier de propriétés ("keystone.properties").

La prise en compte des options suit la hiérarchie suivante (du plus important au moins important) :

ligne de commande sous la forme "--name=value"
le fichier "file:keystone.properties", au même niveau que l'archive
le fichier "classpath:keystone.properties"
le fichier "classpath:META-INF/keystone.properties"

Nom	Description
Main-Class	java main class

BootStrap.haltOnError	true\|false (par défaut : true), si vrai le système s'arrête à la première erreur, sinon il continue comme il peut (utile lors de mise à jour "tendue")

BootStrap.explode	true\|false (par défaut : true), si vrai, l'archive va être extraite dans le répertoire de démarrage (les répertoires "lib", "tools", et "plugins" vont être alimenté avec les ressources de l'archive de départ)
BootStrap.cleanUpTools	true\|false (par défaut : false), si vrai le répertoire 'tools' va être nettoyer au démarrage du système
BootStrap.cleanUpLib	true\|false (par défaut : true), si vrai le répertoire 'lib' va être nettoyer au démarrage du système
BootStrap.cleanUpPlugins	true\|false (par défaut : false), si vrai le répertoire 'plugins' va être nettoyer au démarrage du système

BootStrap.verbose	true\|false (par défaut : false), active le mode de log 'verbose'
BootStrap.info	true\|false (par défaut : true), active le mode de log 'info'
BootStrap.logFile	fichier de log du bootstrap (par défaut : aucun)

BootStrap.includeJavaHomeLib	true\|false (par défaut : false), inclus le répertoire de librairies du jdk dans le classpath
BootStrap.includeSystemClassLoader	true\|false (par défaut : false), inclus le classloader système dans le classpath
BootStrap.includePlugins	true\|false (par défaut : true), inclus le répertoire des plugins dans le classpath

Le boot rajoute deux propriétés système pouvant être utiliser dans votre application :

BootStrap.location : le chemin complet de l'archive qui a été démarré via la ligne de commande
BootStrap.home : le répertoire de démarrage

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.1</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>

Soyez indulgent ce projet est tout récent, et je vais lui faire subir sa première épreuve du feu avec le projet winstone.

Dès que celle-ci m'aura permis de sécher ce projet, je compléterais cet article avec un "how to bootstrap with keystone".

A bientôt donc !

Consultation Gratuite: Les architectes, des experts à votre service

Jérôme Guibert — Tue, 29 Mar 2011 15:18:00 +0200

Bonjour, Je vous invite tous à retrouver J2G-design les vendredi 29 avril et 6 mai de 14h à 19h à la foire de Paris pour une consultation gratuite.

Home Staging, shopping déco, réaménagement, rénovation, suivi de chantier… sont des moments (très) importants pour chacun et qui vont justement vous changer la vie de tous les jours. Alors, profitez de la foire de Paris pour lui poser vos questions !

Ploum : le Don Quichotte des temps modernes

Jérôme Guibert — Thu, 03 Mar 2011 14:29:00 +0100

Ce n'est pas une histoire de moulin, et pourtant une étude sur la vie trépidante d'une moule :-p devient tout d'un coup passionnant !

Parlons peu, écrivons bien, mais surtout lisons !
Il est des proses que j'aime à lire, et celle-ci en fait partie !! Ces billets, je les attends comme des petits pains aux chocolats tout juste sortis du four.

De la partie de poillade autour de gens bizarre qui applaudissent tant ils s'étonnent d'être (encore) en vie à l’atterrissage de leur avion, en passant par une analyse très poussée de la carto-bio-graphie interne d'une moule, vous aurez un ton, une langue, vindicative comme on en trouve peu.
Ce qui n'empêche pas de toucher du doigt/de la plume devrais-je dire, et faire mouche !

En réponse à son dernier article sur face-de-bouc et la mort du web, j'ouvre à mon tour ma prose, pour vous dire que ça fait du bien de vous lire !! Merci

Syntax Highlighter

Jérôme Guibert — Thu, 03 Mar 2011 11:16:00 +0100

Un "colorisateur syntaxique" complet, efficace, simple à l'usage et facile à installer!

Un petit mot sur un outil javascript fabuleux pour le web c'est le Syntax Highlighter d'Alex Gorbatchev.

Très utilisé, il supporte les syntaxes: java, js, schell, C, php, xml, sql, xml, css, erlang, mais aussi clojure !! (une liste exhaustive des syntaxes est disponible sur ce billet o)

C'est Daniel Solano Gómez à développé une "brush" pour clojure (disponible sur git hub ou via le fichier attaché à ce billet).
Un exemple de ce que cela donne:

(def hello (fn [] "Hello world"))
-> #'user/hello
(hello)
-> "Hello world"

Intégration avec Dotclear

récupération du code source
dézippage et installation de tous les fichiers javascript dans le dossier "js/sh" du thème ({{tpl:BlogThemeURL}}/js/sh)
Choix du style générale (pour moi c'est "shCoreEclipse.css") et intégration dans le css de mon thème

Inclusion des fichiers javascript dans le footer (je vous conseille de les copiers dans un seul et même fichier "sh.js"

"{{tpl:BlogThemeURL}}/js/sh/shCore.js"
"{{tpl:BlogThemeURL}}/js/sh/shAutoloader.js"

Et du bout de code suivant (il charge dans la navigateur, les "brush" qui vont bien à la demande)

$(document).ready(function(){
SyntaxHighlighter.autoloader.apply(null, syntaxHighlighterPath(
'clojure clj               @shBrushClojure.js',
'applescript            @shBrushAppleScript.js',
'actionscript3 as3      @shBrushAS3.js',
'bash shell             @shBrushBash.js',
'coldfusion cf          @shBrushColdFusion.js',
'cpp c                  @shBrushCpp.js',
'c# c-sharp csharp      @shBrushCSharp.js',
'css                    @shBrushCss.js',
'delphi pascal          @shBrushDelphi.js',
'diff patch pas         @shBrushDiff.js',
'erl erlang             @shBrushErlang.js',
'groovy                 @shBrushGroovy.js',
'java                   @shBrushJava.js',
'jfx javafx             @shBrushJavaFX.js',
'js jscript javascript  @shBrushJScript.js',
'perl pl                @shBrushPerl.js',
'php                    @shBrushPhp.js',
'text plain             @shBrushPlain.js',
'py python              @shBrushPython.js',
'ruby rails ror rb      @shBrushRuby.js',
'sass scss              @shBrushSass.js',
'scala                  @shBrushScala.js',
'sql                    @shBrushSql.js',
'vb vbnet               @shBrushVb.js',
'xml xhtml xslt html    @shBrushXml.js'
));
SyntaxHighlighter.config.bloggerMode = true;
SyntaxHighlighter.defaults.toolbar=false;
SyntaxHighlighter.defaults.gutter=false;
SyntaxHighlighter.all();
});

Modification du template "footer.html" ( {{tpl:BlogThemeURL}}/tpl/_footer.html), pour activer le système pour les billets vue en post :

Attention, cela suppose que vous avez "jquery" d'installer dans votre thème .

Exemple d'utilisation

Pour afficher

(def hello (fn [] "Hello world"))
-> #'user/hello
(hello)
-> "Hello world"

vous devez saisir:

<script type="syntaxhighlighter" class="brush: js"><![CDATA[
(def hello (fn [] "Hello world"))
-> #'user/hello
(hello)
-> "Hello world"
]]></script>

Winstone - conteneur de servlet

Jérôme Guibert — Tue, 01 Mar 2011 15:48:00 +0100

Winstone est un conteneur de servlet léger qui a été écrit dans le but de fournir l'essentiel des fonctionnalités utilisées dans une application WEB, en moins de 300Ko.

Winstone est un conteneur de servlet léger qui a été écrit dans le but de fournir l'essentiel des fonctionnalités utilisées dans une application WEB.

Il n'est pas destiné à être un serveur J2EE complètement fonctionnel. Cela veut dire qu'il ne supporte pas les API non relatives au servlet: JNDI, JavaMail, EJBs, etc...
Ceci est laissé à d'autre excellents conteneur comme Jetty, tomcat, Resin, JRun, Weblogic, ...
Toutefois, dans la version 1.0.0, une implémentation JNDI vient d'être intégrer afin de gérér les datasource et les sessions smtp.

Des fois, vous avez juste besoin d'un petit conteneur de servlet, rapidement opérationel, pour tester, prototyper, monter, ou déployer une application web avec son serveur dans un simple jar.
C'est là où Winstone remplie sa fonction.

La version 1.0.0 ce trouve sur http://code.google.com/p/winstone/

Les buts originels

Fournir la fonctionnalité de conteneur de servlet d'une façon efficace et rapide
Conserver une distribution de base avec une taile aussi faible que possible: 166KB pour la version 0.9.10 sur sourceforge, 295Ko pour la version 1.0.0 sur google code (sans les jars de log et la servlet-api et toute les informations de debug )
Conserver les fichiers de configuration à un minimum absolu, en utilisant les options de ligne de commande pour éventuellement remplacer/surcharger celle compilé par défaut.
Offrir la prise en charge optionnel de la compilation JSP en utilisant Jasper Apache. (http://jakarta.apache.org)

Pourquoi le nom "Winstone"

Les versions initiales de Winstone ont été créées par Rick Knowles (La page d'accueil de ce projet est http://winstone.sourceforge.net où vous trouverez la version 0.9.10).

Officiellement, il a cessé de supporter Winstone, préférant se concentrer sur d'autres projets. Officieusement, il continue toujours à répondre à la mailing list , merci à lui.
Depuis lors, avec sa permission, nous reprenons le suivi de ce «petit» projet qui a titiller nos neurones.

Nous espérons que nos petits doigts instilleront suffisamment de magie dans ce projet, et que son usage soit pour vous source de tranquillité.

Utiliser Winstone

Lancement

vous pourrez trouver:

la liste des options disponible sur ce lien http://code.google.com/p/winstone/wiki/CmdLineOption
des informations sur le paramètrage du JNDI: http://code.google.com/p/winstone/wiki/JndiSupport (celui-ci embarque une implémentation minimaliste d'un pool de connection, des alias jndi, des sessions SMTP, des propriétés basiques, ... )

Construire le projet depuis les sources

Pour compiler le projet vous aurez besoin de télécharger et installer Apache Maven (v2.x) et une JVM.
Les instructions suivant assume que vous avez déjà installé Maven et que vous avez la commande shell dans votre path (pour obtenir Maven: http://maven.apache.org/).

Recuperer les sources (soit en téléchargeant une archive, soit depuis google code avec l'outil Subversion)

Le fichier winstone-X.X.X.boot.jar se trouvera dans le répértoire "target".

La version 1.0.0

mavenisation (en version 2)
utilisation de SLF4J, reprise de toute la gestion des log
ajout d'une implémentation JNDI plus complete (pool de connection, gestion des alias, ...)
ajout de test unitaire
supression du code mort
extention des options en ligne de commande,
amélioration de la gestion des types mime
et plein d'autres encore....

Vous pourrez trouver le change log à cette adresse http://code.google.com/p/winstone/wiki/ChangeLog

Le futur

Dans un avenir proche, la priorité est de créer la release de cette version 1.0.0 qui porte beaucoup de changement.

Sinon, dans les bacs:

créér un plugin maven, jenkins (anciennement hudson)
optimiser l'algorithme de matching des urls
compléter la documentation
Obtenir un profile de consomation mémoire plus claire
Ajouter des tests plus poussés sur les connecteur AJ...

Toute l'aide, commentaires est la bienvenue !!

Les biotic games, vous connaissez ?

Jérôme Guibert — Tue, 01 Mar 2011 11:42:00 +0100

Ingmar Riedel-Kruse et son équipe viennent de développer les premiers biotic games.

Revisitez le Pac man biologique !!

Ingmar Riedel-Kruse et son équipe viennent de développer les premiers biotic games.

Créer comme un hommages à des monuments du jeu vidéo (Pong, Pac man...), ils sont résoluement tourné vers une interaction du joueur avec des organismes vivants. J'ai bien dit vivant, et pas une simulation d'organisme vivant!!

Bien qu'ils semblent anodins, la mise au point de ces petit jeu nécéssite toute de même une bonne maîtrise de problèmatique comme la reconnaissance de forme, la numérations, le traitement d'image en temps réél, ...

Ces créations n'ont pas d'application commercial en tant que "jeu vidéo", mais peuvent servir à eduquer d'une manière ludique nos jeunes chérubins!