The French Hack

Activer HTTPS de httpd sur ubuntu

2011-12-03T07:48:00.000-08:00

Pour activer https sur Ubuntu

a2ensite default-ssl

Update Grub in Ubuntu

2011-12-02T05:32:00.000-08:00

In order to start have your windows first in your Ubuntu 11.10, just change the order of the files in /etc/grub.d by changing the number starting each entry.

By default, the directory contains the files : 00_header, 01_linux, 02_linux_xen, 03_os_probe etc.
If you change the file names so that numbers looks like 00_header, 01_os_probe, 02_linux, 03_linux_xen

And then run grub-update (to update /boot/grub/grub.cfg) in command line. Windows will launch first at startup.

Aptitude sur Ubuntu

2011-10-26T00:21:00.000-07:00

Installation a travers un proxy

vi /etc/apt/apt.conf.d/05aptitude

Ajouter la ligne :

Acquire::http::Proxy "http://myusername:mypasswd@myproxy:3128";

Rechercher un package à partir de son nom

root@ubuntu:/home/clement# apt-cache search jetty
libjetty-extra - Java servlet engine and webserver -- extra libraries
libjetty-extra-java - Java servlet engine and webserver -- extra libraries
libjetty-java - Java servlet engine and webserver -- core libraries
libjetty-java-doc - Javadoc for the Jetty API
jetty - Java servlet engine and webserver
liblogback-java - flexible logging library for Java
liblogback-java-doc - flexible logging library for Java - documentation
liboauth-signpost-java - simple OAuth message signing for Java
libspring-security-2.0-java-doc - documentation for Spring Security 2.0
libspring-security-acl-2.0-java - modular Java/J2EE application security framework - ACL
libspring-security-core-2.0-java - modular Java/J2EE application security framework - Core
libspring-security-ntlm-2.0-java - modular Java/J2EE application security framework - NTLM
libspring-security-portlet-2.0-java - modular Java/J2EE application security framework - Portlet
libspring-security-taglibs-2.0-java - modular Java/J2EE application security framework - Taglibs
solr-common - enterprise search server based on Lucene - common files
solr-jetty - enterprise search server based on Lucene - Jetty integration

Dump et load avec MySQL

2011-03-01T00:28:00.000-08:00

How to make a dump

mysqldump -umyuser -pmypasswd mydb > dumpinteg_20110228.sql

How to load a dump

mysql -umyuser -pmypasswd mydb --default-character-set=utf8 < dumpinteg_20110228.sql

Installer un serveur subversion sur apache sur Ubuntu

2011-02-22T08:26:00.000-08:00

Nous allons installer simplement un serveur svn


1. Installer les packages:
apt-get install subversion libapache2-svn

ou 
 
yum install mod_dav_svn 

(yum search dav)
2. Créer le répository

mkdir /var/svn
svnadmin create /var/svn/
chown -R www-data:www-data /var/svn/
chmod -R g+ws /var/svn/

3. Créer le fichier d'authentification

htpasswd -c -m /etc/apache2/dav_svn.passwd 

4. Configurer apache
<Location /svn >
DAV svn
SVNPath /var/svn
AuthType Basic
AuthName "Subversion Repository"
AuthUserFile /etc/apache2/dav_svn.passwd
Require valid-user
</Location /svn >
5.Redémarrer Apache
/etc/init.d/apache2 restart

deploiement d'un fichier

2011-02-21T06:47:00.000-08:00

Pour déployer un fichier sur archiva :

clement@clement-laptop:~/Bureau$ mvn deploy:deploy-file -Dfile=gwt-servlet.jar -DgroupId=com.google.gwt -DartifactId= -Dversion=1.3.0 -Dpackaging=jar -DrepositoryId=archiva.internal -Durl=http://archiva/repository/internal -DgeneratePom=true

Attention a bien fournir le proxy correct (https) et a fournir le user Id

 <proxies>
     <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http https</protocol>
      <host>proxy.mdp</host>
      <port>3128</port>
      <nonProxyHosts>vmjirarh01|archiva</nonProxyHosts>
    </proxy>
  </proxies>


 <server>
      <id>archiva.internal</id>
      <username>upload</username>
      <password>ftj0bs-09</password>
    </server>
    <server>
      <id>archiva.snapshots</id>
      <username>upload</username>
      <password>ftj0bs-09</password>
    </server>

Bréviaire d'Oracle

2010-12-08T05:30:00.000-08:00

Se connecter en tant que sysdba

Se connecter en avec l'utilisateur oracle (utilisateur unix) sur la machine hébergeant l'instance, puis :


sqlplus / as sysdba

Créer un USER


CREATE USER PHARERHCSD IDENTIFIED BY PHARERHCSD
DEFAULT tablespace PHARERHCSD;

GRANT CONNECT,RESOURCE,DBA to PHARERHCSD;

connect PHARERHCSD/PHARERHCSD

Lister toutes les tables

Lister toutes les tables de l'utilisateur


select * from user_tables

Lister toutes les tables


select * from all_tables

Create a tablespace


create tablespace PHARERHCSD datafile '/data/ora/D59A001/u03/dta_PHARERHCSD.dbf'
size 10M
autoextend on maxsize 200M
extent management local uniform size 64K;

Drop a tablespace


DROP TABLESPACE DTA_ELECTION_ISOPROD_20081216
INCLUDING CONTENTS CASCADE CONSTRAINTS;
DROP TABLESPACE tbs_02 INCLUDING CONTENTS AND DATAFILES;

Libérer de l'espace disque


ALTER DATABASE DATAFILE '/data/ora/D59A001/u03/dta_ELECT_isoprod_20081216.dbf' offline DROP;
conn / as sysdba
shutdown immediate;
startup mount
host
$ cp /u01/oradata/tools01.dbf /u06/oradata/tools01.dbf
$ exit
alter database rename file '/u01/oradata/tools01.dbf' to '/u06/oradata/tools01.dbf';
alter database open
host
$ rm /u01/oradata/tools.01.dbf
$ exit

Si le message est :
ORA-01034: ORACLE not available, cela signifie que l'instance n'est pas démarrée. Et pour démarrer l'instance oracle :
export ORACLE_SID


sqlplus /nolog
connect as sysdba
startup

Pour créer un tablespace


sqlplus system/pwd
CREATE TABLESPACE MYTABLESPACE DATAFILE  '/export/oradata/mynamespace.dbf' size 5M MINIMUM EXTENT 65536 DEFAULT STORAGE (initial 1M next 1M MAXEXTENTS 500 PCTINCREASE 0);

Pour contrôler le listener :


lsnrctl stop
lsnrctl start
lsnrctl services

Voici un exemple de fichier listener.ora

# listener.ora Network Configuration File: /u01/app/oracle/product/11.2.0/dbhome_1/network/admin/listener.ora
# Generated by Oracle configuration tools.

LISTENER_MYDB =
 (DESCRIPTION_LIST =
   (DESCRIPTION =
     (ADDRESS = (PROTOCOL = TCP)(HOST = mymachine.mycompany.com)(PORT = 1521))
   )
 )

Voici un exemple de fichier TNSNAMES.ORA

MYDB =
 (DESCRIPTION =
   (ADDRESS = (PROTOCOL = TCP)(HOST = mymachine.mycompany.com)(PORT = 1521))
   (CONNECT_DATA =
     (SERVER = DEDICATED)
     (SERVICE_NAME = mydb.mycompany.com)
   )
 )

Si le message est no services started il y a une erreur d'écriture dans le fichier listener.ora

Exporter des données, créer des dumps oracle :


exp userid=MYUSERFROM@MYSID file=D:\export_full.dump log=d:\export_full.log

Importer des données, insérer des dumps oracles :


imp system/mymdp@mydb file=/local/schemas/mydbdump.dmp FULL=Y ROWS=Y Ignore=Y FROMUSER=MYSRCTABLESPACE TOUSER=MYDSTTABLESPACE


imp system/ouch  ROWS=Y Ignore=Y  file=D:\export_full.dump TOUSER=MYUSERFROM FROMUSER=MYUSERFROM

Créer un user


create user myuser identified by myuser_pwd default tablespace MYTABLESPACE temporary tablespace TEMP;

Affecter les droits à cet utilisateur :


grant connect,resource to mydb;
Grant succeeded.

Vérifier que l'on peut se connecter avec cet utilisateur

connect myuser/mypwd

Affecter à cet utilisateur le namespace par défauts


ALTER USER myuser  QUOTA UNLIMITED ON MYTABLESPACE;

Créer une instance ORACLE

Plusieurs instances peuvent tourner sur un même numéro de port. Le SID permet de faire la distinction. Dans le plupart des cas, il vaut mieux éviter de créer de nouvelles instances.
Il est suffisant de créer un nouvel utilisateur, l'utilisateur est une notion confondue avec celle du schéma.

Copier le fichier
dbca.rsp et l'éditer


dbca -progress_only -responseFile dbca.rsp

L'instance est créee

Installer sqlplus de la version XE (client et serveur)

2010-12-01T02:38:00.000-08:00

Oracle propose une distribution libre de sa base avec XE(expresse edition).
Téléchargez oracle-xe-client-10.2.0.1-1.0

Puis installez :

rpm -i oracle-xe-client-10.2.0.1-1.0.rpm

Comme il fallait s'y attendre, ORACLE ne faitrien pour nous simplifier la tâche. Car à ce point, rien n'est fait :
Il faut d'abord créer le répertoire de configuration :

mkdirhier /usr/lib/oracle/xe/app/oracle/product/10.2.0/client/network/admin/

Puis
La variable définir la variable TNS_ADMIN pour qu'elle pointe sur le répertoire de configuration :

export TNS_ADMIN=/usr/lib/oracle/xe/app/oracle/product/10.2.0/client/network/admin/
export ORACLE_HOME=/usr/lib/oracle/xe/app/oracle/product/10.2.0/server
export ORACLE_SID=ARCHIVER
export NLS_LANG=`$ORACLE_HOME/bin/nls_lang.sh`
PATH=$ORACLE_HOME/bin:$PATH

Le fichier tnsnames.ora contient les informations suivantes

MYSID =
  (DESCRIPTION =
    (ADDRESS = (PROTOCOL = TCP)(HOST = 66.65.66.66)(PORT = 1521))
    (CONNECT_DATA =
      (SERVER = DEDICATED)
      (SERVICE_NAME = ARCHIVER)
    )
  )

On s'y connecte ensuite par la ligne de commande :

sqlplus MYUSER/MYPWD@MYSID

Faire du port forwarding à l'aide de SSH

2010-11-29T06:48:00.000-08:00

Pour faire du port forwarding, éditer le fichier .ssh/config et lui donne le contenu suivant
(Ici le port 80 de la machine est forwardée sur la machine 55.6.110.96 sur le port 1521)

Host 127.0.0.1
        LocalForward 80 55.6.110.96:1521
        GatewayPorts yes

Pour que la connexion fonctionne, il est nécessaire que le programme ssh soit actif (C'est à dire qu'il soit démarré et figure dans les process de la machine locale). Il est également possible de procéder à l'opération inverse en se servant de la commande RemotePort

To set a specific user to connect a remot host

Host myhost
        User myuser
        ForwardX11 yes

Externaliser la configuration de ses webapp

2010-11-29T06:39:00.000-08:00

Dans les webapps utilisant spring il est possible d'externaliser sa configuration à l'aide de variables d'environnement pour log4j :

<bean id="log4jConfigurer"
class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetClass">
<value>org.springframework.util.Log4jConfigurer</value>
</property>
<property name="targetMethod">
<value>initLogging</value>
</property>
<property name="arguments">
<list>
<value>${MYREP_CONF}/log4j.xml</value>
<!-- or you could use an absolute path: <value>file:D:\\etc\\myapp\\log4j.properties</value> -->
</list>
</property>
</bean>

Port forwarding à l'aide de iptable

2010-11-25T08:40:00.001-08:00

Ip/Port rewriting

Ces commandes se passent en root

Ip table permet de forwarder des ports d'une machine vers une autre.

Les instructions sont à renouveler à chaque démarrage de la machine

#Réécriture du port d'un paquet
iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 1521 -j DNAT --to 55.6.110.96:1521

iptables -A INPUT -p tcp -m state --state NEW --dport 1521 -i eth0 -j ACCEPT
#Sécurité par défaut autorise l'accès à la chaine forward
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 1 > /proc/sys/net/ipv6/ip_forward

# Pour intercepter les paquets à destination d'une ip différente de celle de l'interface

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

Pour lister les chaines principales

iptable -L

Pour lister toutes les de nat (ip/port rewriting)

iptables -L -t nat

Pour supprimer les règles

iptables -F -t nat

Utiliser apache en frontal et forwarder les ports sur un Jetty

2010-11-04T02:31:00.000-07:00

Je veux mettre en place un apache frontal lequel délègue sa requête à un serveur archiva ouvert sur le port 8081. Seul le port 80 est ouvert sur le réseau. Je ne souhaite pas de connecteur complexe, car il ne s'agit pas d'une question de performance.
Pour ce faire, j'ai utilisé le mod_proxy de apache et les virtualHost.

<IfModule mod_proxy.c>
ProxyRequests Off

<Proxy *>
Order deny,allow
Allow from all
</Proxy>

<VirtualHost archiva:80>
   ServerAdmin webmaster@dummy-host.example.com
   ProxyPass / http://archiva:8081/
    ProxyPassReverse / http://archiva:8081/
    ErrorLog logs/dummy-host.example.com-error_log
   CustomLog logs/dummy-host.example.com-access_log common
</VirtualHost>

Créer un partage Webdav sur Ubuntu 10.4

2010-09-28T00:49:00.001-07:00

Installer WebSAV sur apache2

Ajouter les lignes suivantes dans le fichier /etc/apache2/sites-available/default

<Directory "/var/www/webdav/">
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
</Directory>
Alias /webdav /var/www/webdav/
<Location /webdav>
DAV On
AuthType Basic
AuthName "webdav"
AuthUserFile /var/www/.passwd.dav
Require valid-user
DavMinTimeout 600
<LimitExcept GET PUT HEAD OPTIONS POST>
Require valid-user
</LimitExcept>
</Location>

Gérer les droits

Puis nous allons créer les mots de passe.

htpasswd -c /var/www/.passwd.dav myuser
chown root:www-data /var/www/.passwd.dav
chmod 640 /var/www/.passwd.dav
chmod -R 0777 /var/www/webdav
chown www-data:www-data /var/www/webdav
/etc/init.d/apache2 restart

Intégration continue avec Hudson et Maven

2010-06-10T02:43:00.000-07:00

Environnement

Avant de donner la recette pour la mise en oeuvre de hudson, nous
allons donner quelques définitions. En effet, certains termes
utilisé dans ce document ont un sens variable suivant le
contexte.

Précisons d'abord les rôles des différents
environnements :

Environnement d'Intégration : sert à
valider manuellement que le le comportement du produit est
identique sur les environnements de développement et sur la
plateforme cible. L'environnement d'intégration doit être
un clone des plateformes de production.
Environnement Intégration continue : sert à
valider automatiquement que le le comportement du produit est
identique sur les environnements de développement et sur la
plateforme cible. L'environnement d'intégration doit être
un clone des plateformes de production.
Environnement de Validation :
sert à vérifier
que le produit est conforme aux spécifications.

Jeu de test :
Ensemble de données nécessaires au passage d'un test

Test unitaire : Théoriquement
il s'agit d'un test vérifiant une exigence, mais dans ce
document, nous l'utiliserons dans son acception consacrée test
Junit.

Bénéfices de l'intégration
continue

Dans les configurations de développement JAVA« standard »,
le codage s'effectue sur Windows et l'intégration s'effectue
sur LINUX/UNIX, il est donc fréquent d'avoir des surprises au
moment de passer sur l'environnement cible, les environnements
d'intégration permettent anticiper les problèmes
techniques.
L'intégrateur identifie les dysfonctionnements et les
corrige. Malheureusement, dans la plupart des configurations projet,
personne n'étant affecté exclusivement à
l'intégration et les soucis d'intégration tendent à
être reléguées aux dernières tâches.

Au delà de l'effet de mode, le principal bienfait de
l'intégration continue sera d'améliorer la visibilité
de ces problématiques.
L’intégration continue valide automatiquement le
produit sur la plateforme cible.

Permet de détecter au plus tôt les problèmes
de dépendance aux environnements : File System, Encoding,
Case-sensitive, performances etc.
Permet de lisser le stress dans l'équipe (plus de
pression dans les phases précoces, moins au moment de la
livraison)
Il donne une aperçu de la qualité du produit au
chef de projet et donne confiance au moment de la livraison
.

Impacts structurants de l'intégration
continue

Contraintes de codage

L'ensemble des projets sur le référentiel de source
doit être compilable à tout moment.

Pour l'intégration continue, le développeur est
contraint d'écrire des tests unitaires.

Test unitaires

Dans un monde systématique, chaque exigence devrait être
vérifiée par un test unitaire, inversement, chaque test
unitaire devrait se mettre en relation avec une seule exigence.
Cependant, dans le monde réel, un test unitaire pourra être
associé à plusieurs exigences, une exigence pourra
n'être pas couverte... etc. In fine le développeur
arbitrera (mais avec un minimum d'expérience, cela se passe
bien. )
A chaque TU est associé un jeu de tests, mais aucune
hypothèse de données préalable ne peut être
faite. Que l'on parte d'une base totalement vidangée ou pleine
de donnée, le résultat du test unitaire doit être
le même. D'autre part, le séquence des TU ne doit pas
non plus conditionner le résultat.

Ressources

L’intégration
requiert un serveur dédié pour hudson
Il faut une base de données
par utilisateur

(Elle peux se situer sur la machine de
développement ou sur un serveur mutualisé)

Contrainte de conception

Il faut utiliser maven pour
l'assemblage
Les test unitaires doivent être
écrit avec Junit

Au quotidien

Il faut vraiment s’impliquer
dans la supervision des builds et être vigilant tout au long
du développement du produit : codage, intégration,
validation
L'équipe doit s'organiser
dans ce but, c'est-à-dire qu'il faut un responsable
Intégration Continue (le même que le responsable GCONF)

Mise en oeuvre

Installer un serveur hudson
Planifier les tâches à des horaires où la
machine n'est pas trop chargée

De The French Hack

Transaction explicites sous Spring et JPA dans les applications Batch

2010-05-26T03:00:00.000-07:00

Il m'a été difficile d'utiliser une application de traitement batch utilisant Hibernate, JPA. En utilisant des transactions explicite.

J'avais le message "org.hibernate.SessionException: Session is closed!"

Pour démmarrer le contexte transactionnel, j'ai utilisé les lignes suivantes


DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setName("MaTransaction");
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
/** pour démarrer le context transactionnel */
transactionManager.getTransaction(def);

Comment économiser de la mémoire :
- Faire des commit intermédiaires

Comment gagner de la vitesse :
- Faire des insertions et des select dans une table est une opération couteuse (car le recalcul des index prend de plus en plus de temps)

Changer le splash screen sur Ubuntu 10.4

2010-05-25T13:50:00.001-07:00

http://maketecheasier.com/change-login-and-boot-screen-in-ubuntu-lucid/2010/05/13

Utilisation des curseurs dans Mysql

2010-05-04T01:54:00.000-07:00


DELIMITER |
CREATE PROCEDURE updateTable()
BEGIN
DECLARE done INT DEFAULT 0;
DECLARE description_population_type2 TEXT;
DECLARE nom_monentite_type2 CHAR(50);
DECLARE cur1 CURSOR FOR select nom_monentite, description_population from sp_monentite where id_gp=2;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;
OPEN cur1;
REPEAT
FETCH cur1 INTO nom_monentite_type2, description_population_type2;
IF NOT done THEN
UPDATE sp_monentite 
SET description_population = description_population_type2 
WHERE nom_monentite_type2=nom_monentite AND id_gp=1;
END IF;
UNTIL done END REPEAT;
CLOSE cur1;
END|

Procédure stockée

Guide de revue de code

2010-04-13T07:07:00.000-07:00

Ci dessous un memorandum sur les points qui ont été mis en défaut sur des projets réel avec des conséquences réelles sur les charges et le planning du projet.

Chacun de ces points est à mettre en oeuvre le plus tôt possible, plus le temps passe et plus le coût est élevé pour revenir dans une démarche de qualité.

Bonne pratiques de développement

Structuration des projets

Un projet devrait contenir un minimum de dépendances entre les modules. La seule raison motivant un découpage de garantir l'indépendance des cycles de vie. Un projet IHM possédants des script de traitement par lot devrait être structuré de la manière suivante :

- Un projet-parent
- Un projet dao + business + service
- Un projet IHM (war)
- Un projet batch
- Un projet factorisant le code de test (Constitution de jeu de test)
- Un jeu de test de référence
- Un jeu de test restreint
- Un jeu de test à volumétrie normale

Recommandations

Utiliser des interfaces uniquement si nécessaire, quand il existe une probabilité réelle qu'une interfaces ait plusieurs réalisations.
Ne pas se servir des exceptions pour remonter des codes d'erreurs.

Bonnes pratiques de codage de tests unitaires

Un test unitaire doit pouvoir partir d'une base vierge
Dans les tests junits dérivés de spring, vérifier que les méthodes d'extraction communes sont dans la méthode onSetUp().
Penser à valider le programme par des jeux de test importants. Si certains tests génèrent des erreurs en occupant trop de mémoire, il vaut mieux ne pas masquer le problème en augmentant la taille mémoire sur la machine de développement. Sur le long terme, il vaut mieux résoudre résoudre le problème par la conception sans utiliser la puissance du matériel.

Bonnes pratiques d'écriture

La manière de coder peut améliorer la reprise du code dans le cas de maintenance. Il est possible d'utiliser des outils de type checkstyle ou PMD. Toutefois, ces outils ne sont pas toujours pertinents parce que trop verbeux.
Formater le code de manière homogène en utilisant un outils de formatage automatique
Mettre des commentaires quand c'est nécessaire
Sur la couche DAO : vérifier que les noms de méthode sont cohérents entre eux
Vérifier que les noms de variables permettent de deviner leur contenu
Vérifier que les tests unitaires donne des messages explicite en cas de plantage (pas de fail sans argument)
Ne pas utiliser les séquences : « ? : » pour les tests if. Toujours mettre des crochets

Merger à l'aide de SVN

2010-03-22T06:15:00.000-07:00

Utilisation des patch dans SVN

Avec SVN, pour reporter les modifications d'une branche vers une autre. Il existe plusieurs méthodes :

La commande merge fournie avec SVN (Méthode recommandée): Cette méthode ne s'applique que si les fichiers modifiés sont connecté au référentiel SVN, mais ce moyen est le plus simple.
Méthode utilisant l'IDE eclipse : Elle présente des avantage pour la représentation de changes. Contrairement à ce que l'on pourrait croire, il s'agit rarement de la méthode la plus simple, en effet le fourmillement d'options sur une GUI entraine une certaine confusion.
Méthode basée sur les fichiers de patch : cette méthode utilise le standard udiff et peux s'appliquer sur des fichiers n'étant pas connectés au référentiel de source. Cette méthode n'est pas automatique mais elle est souple.

Pour illustrer un report nous allons utiliser l'exemple d'un report d'une correction de bug sur la branche en maintenance (lot 1) vers la branche en cours de développement (lot 2), la branche lot 2 est en cours de développement, c'est donc le tronc.

De The French Hack

Cette opération s'effectue en 5 temps :

Récuppération du numéro de révision
Checkout de la branche sur laquelle le report est effectué
Report des modifications et fusion
Résolution des conflits
Commit

Méthode en ligne de commande utilisant subversion (Méthode recommandée)

La première opération consiste à repèrer dans l'historique la version à partir de laquelle nous souhaitons effectuer le report. Nous pouvons nous baser sur les dates de modifications, les commentaires, les dates de création de branches... tou ce qu'on veut !


bash> svn log -r{20100401}:HEAD http://svnserver/my-product/developpement/branches/my-module-dao-lot1

Récuppération du numéro de révision

Problème des droits acces 
------------------------------------------------------------------------
r3389 | zegugusse | 2010-04-28 12:15:38 +0200 (mer, 28 avr 2010) | 1 line

Le montant des couts pour que les valeurs jusqu'a 9 999 999 999 puissent etre stockées et non arrondies
------------------------------------------------------------------------
r3390 | zegugusse  | 2010-04-29 09:25:29 +0200 (jeu, 29 avr 2010) | 1 line

Problème des droits 
------------------------------------------------------------------------
r3394 | zegugusse  | 2010-05-04 09:12:01 +0200 (mar, 04 mai 2010) | 2 lines


------------------------------------------------------------------------
r3394 | ungusse | 2010-05-04 09:12:01 +0200 (mar, 04 mai 2010) | 2 lines

Création des branches lot2

------------------------------------------------------------------------
r3397 | ungusse | 2010-05-04 09:12:33 +0200 (mar, 04 mai 2010) | 1 line


------------------------------------------------------------------------
r3528 | ungusse | 2010-05-26 12:09:30 +0200 (mer, 26 mai 2010) | 2 lines

Ajout des codes d'erreur

------------------------------------------------------------------------
r3574 | lotrgusse | 2010-06-01 15:25:34 +0200 (mar, 01 jun 2010) | 1 line

Ajout du libellé long . Change D76.
------------------------------------------------------------------------
r3577 | zegugusse | 2010-06-01 16:09:25 +0200 (mar, 01 jun 2010) | 1 line

Defect Client D58
------------------------------------------------------------------------
r3579 | lotrgusse | 2010-06-01 17:35:41 +0200 (mar, 01 jun 2010) | 1 line

Modification du comportement de l'écran de sélection des cibles.
------------------------------------------------------------------------
r3583 | zegugusse | 2010-06-02 12:22:50 +0200 (mer, 02 jun 2010) | 1 line

Defect Client D58
------------------------------------------------------------------------

Checkout de la branche sur laquelle le report est effectué


svn co  http://svnserver/my-product/developpement/branches/my-module-branch my-module-dao-trunk-workcopy

Report des modifications et fusion

Maintenant, nous allons reporter les changements intervenu sur la branche my-module-branch entre les versions 1000 et la HEAD



svn merge -r1000:HEAD http://svnserver/my-product/developpement/branches/my-module-dao-lot1 my-module-dao-trunk-workcopy

Le premier paramètre (http://svnserver/my-product/developpement/branches/my-module-dao-lot1) indique la branche d'ou est effectué le rapport
Le second paramètre (my-module-trunk-workcopy) est le chemin du repertoire sur lequel le report est appliqué

Voici le résultat :


[hudson@vm01 ~]$  svn merge -r2650:HEAD http://svnserver/my-product/developpement/branches/my-module-dao-lot1  my-module-dao-trunk/
U    my-module-dao-trunk-workcopy/src/sql/data/load-ref-dev.bat
U    my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/service/common/impl/UtilisateurServiceImpl.java
C    my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java
U    my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/business/projet/impl/ProjetBusinessImpl.java
G    my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/business/objectif/impl/ObjectifBusinessImpl.java
C    my-module-dao-trunk-workcopy/pom.xml

U indique que nous avons procédé à un update
G indique que nous avons procédé à une fusion sans conflit
C indique un conflit

Ensuite nous pouvons observer le resultat à l'aide de la commande : svn st


[hudson@vm01 ~]$ svn st my-module-dao-trunk-workcopy
?      my-module-dao-trunk-workcopy/pom.xml.fusion-gauche.r2650
?      my-module-dao-trunk-workcopy/pom.xml.courant
?      my-module-dao-trunk-workcopy/pom.xml.fusion-droit.r2862
M      my-module-dao-trunk-workcopy/src/sql/data/load-ref-dev.bat
M      my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/service/common/impl/UtilisateurServiceImpl.java
?      my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java.courant
?      my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java.fusion-droit.r2862
?      my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java.fusion-gauche.r2650
C      my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java
M      my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/business/projet/impl/ProjetBusinessImpl.java
M      my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/business/objectif/impl/ObjectifBusinessImpl.java
C      my-module-dao-trunk-workcopy/pom.xml

M indique que le fichier est modifié (Un check in est nécéssaire)
C indique un conflit (Il est nécessaire résoudre)

Résolution des conflits

Avec un éditeur résoudre les conflit dans my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java puis indiquer que le conflit est résolu


vi my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java
svn resolved my-module-dao-trunk-workcopy/src/main/java/com/mycompany/jt/dao/BuildingSecondaireDAO.java

Commit

Pour finaliser, il faut commiter nos modifications


svn ci my-module-dao-trunk-workcopy/

Méthode se basant sur les fichiers de patch

Sous UNIX, une ligne de commande génère ces fichiers de patch :


svn diff  http://svnserver.mycomp/my-product/developpement/trunk/my-project -rN:M

N est la version d'origine M est la version cible.

Pour appliquer ces patchs, se plaçer à la racine du projet à patcher, utiliser la commande :


patch -p0 >mypatchfile

où p est la profondeur

Méthode sur eclipse

Contrairement à ce que l'on pourrait croire, l'utilisation d'eclipse peut être plus difficile que celle de la ligne de commande.

Se placer sur la branche sur laquelle on souhaite effectuer les reports.
Choisir l'ensemble des révisions à reporter. Autrement, l'option starts from copy reporte l'ensemble des modification depuis la création de la branche (ce qui peut n'être pas adéquat dans le cas où la branche à subi plusieurs recopies)
Preview permet de voir quelle sont les révision concernées :

Mysql en case insensitive sur linux Red hat

2010-01-07T00:57:00.000-08:00

Dans le fichier my.ini, sous la section mysqld, ajouter la ligne suivante :


lower_case_table_names=1

Install Mysql from the zipped installation

2009-12-02T06:40:00.000-08:00

Customize a MySQL installation from a zip file is easy :

Look in the configuration file and set the path in it correctly.


"D:\myproject\MySQL\MySQL Server 5.1\my.ini

Once done, you can set it up as a windows service using the simple command line



"D:\myproject\MySQL\MySQL Server 5.1\bin\mysqld.exe" --install
"D:\myproject\MySQL\MySQL Server 5.1\bin\mysqld.exe" --remove

Change the root password




mysqladmin -u root password NEWPASSWORD

Configuring JNDI Javamail resource over SSL for SMTP

2009-11-30T06:05:00.000-08:00

You declare your JAVAMAIL resource into the server.xml (or in the appropriate context file in your configuration directory) file of your tomcat :

              <Resource name="mail/MailServer" auth="Container"
            type="javax.mail.Session"
            mail.smtp.host="smtp.mailserver"
    mail.smtp.port="465"
    mail.smtp.auth="true"
    mail.smtp.user="myuser"
    password="mypassword"
    mail.smtp.starttls.enable="true"
    mail.smtp.socketFactory.class="javax.net.ssl.SSLSocketFactory"
  />

Then your resource is accessible via this URI in your webapp :


java:comp/env/mail/MailServer

Also, you must copy the two files
activation.jar and mail.jar in your tomcat common/lib server.

You may refer to the JIRA documentation where I had this hint

http://www.atlassian.com/software/jira/docs/v3.13/smtpconfig.html

Définition ORACLE

2009-09-30T03:31:00.000-07:00

Définitions :

Instance :
Une instance oracle est un processus destinée à servir les données.
Listener :
Un listener est un processus gérant les connexions lourdes de sql net. Le listener n'est pas indispensable pour faire fonctionner le JDBC
Tablespace :
Un Tablespace est la définition d'un espace sur le système de fichier contenant les données. Dans les bases de données modernes, la notion de Tablespace est plus discrète, car elle ne fait pas référence au données mais au système.
User :
Un user est un espace de table. La notion de schema qui est beaucoup parlante est identique à celle du user.
Database :
Est un ensemble de schémas.

Débuter en JSF

2009-09-16T07:10:00.000-07:00

Faire un tag combobox :

myCommandBean est le nom du bean mise en correspondance la combobox. #{myCommandBean.myfield} est le nom du champ qui stocke l'information.

<h:selectOneListbox  id="myCommandBean"          binding="#{myCommandBean.myfield}" size="1" >
<f:selectItems 
   value="#{myCommandBean.myfieldList}" />
</h:selectOneListbox>

Le fichier face-config.xml contient la configuration de Jface :

<managed-bean>        
<managed-bean-name>myCommandBean</managed-bean-name>
<managed-bean-class>com.mybusiness.MyCommandBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>

Ces lignes permettent de déclarer le bean de stockage des informations de la combo box dans la session. Les valeurs affectée à ce bean pourront être exploitée durant toute la session. C'est une bonne idée que d'utiliser ce scope par défaut.

public List getMyfieldList() {
    List list = new ArrayList();
    list.add(new SelectItem("01", "moncul"));
    list.add(new SelectItem("02", "machemise"));
    return list;
}

Le getter dans le bean com.mybusiness.MyCommandBean utilise une propriété HtmlSelectOneListbox


public HtmlSelectOneListbox getMyfield() {
    return myfield;
}

public void setMyfield(HtmlSelectOneListbox myfield) {
        this.myfield = myfield;
}

Générer des document openXML Word 2003/2007

2009-07-24T06:55:00.000-07:00

Les récents standards OpenXML et Open document permettent de générer des documents sans passer par des APIs propriétaires.

Pour comprendre les formats docx de word, rien de tel que l'exemple. Le contenu en clair du fichier s'observe en dézippant le fichier word (renommert son extension .docx en .zip). Ainsi il est possible d'étudier le contenu. Ce zip comporte plusieurs fichiers :

- word/document.xml : Comporte le contenu
- word/header1.xml, word/headerx.xml: Décrit les entêtes (par section)
- word/footer1.xml : Décrit les pieds de page
- word/styles.xml : Décrit les mises en forme

Les fichiers contenus dans le zip sont nombreux. Le fichier principal est le fichier document.xml.

A priori, l'édition de son contenu ne contient rien qui soit 'user friendly', par exemple :

<w:document>
<w:body>
<w:p w:rsidR="00047630" w:rsidRDefault="00047630">
<w:pPr>
<w:tabs>
<w:tab w:val="center" w:pos="7655"/>
<w:tab w:val="right" w:pos="15451"/>
</w:tabs>
<w:ind w:right="-29"/>
<w:rPr>
<w:rFonts w:ascii="Arial" w:hAnsi="Arial" w:cs="Arial"/>
<w:b/>
<w:bCs/>
<w:sz w:val="22"/>
<w:szCs w:val="22"/>
</w:rPr>
</w:pPr>
<w:r>
<w:rPr>
<w:rFonts w:ascii="Arial" w:hAnsi="Arial" w:cs="Arial"/>
<w:b/>
<w:bCs/>
<w:sz w:val="22"/>
<w:szCs w:val="22"/>
</w:rPr>
<w:t>REGULATION :</w:t>
</w:r>
</w:p>
<w:tbl>
<w:tblPr>
<w:tblW w:w="0" w:type="auto"/>
<w:tblInd w:w="-68" w:type="dxa"/>
<w:tblLayout w:type="fixed"/>
...

Le principe de génération naturel est d'utiliser XSLT (XML Stylesheet Language Transformation) pour effectuer la transformation des données métiers brutes en un fichier document.xml.
(Toutefois, n'oubliez pas que les outils de transformation plus simple tel que Velocity peuvent être approprié dans le cas de traitement élémentaire (http://velocity.apache.org/))

Pour ne pas composer manuellement, le document.xml, mieux vaut l'extraire de votre document modèle et le copier/coller dans un fichier XSL reprenant la structure du document. Puis, en localisant endroits où ajouter les informations dans le fichier, on ajoute les valeurs de notre document XML.

Les balise XSL suivantes sont très utiles

<xsl:value-of select="/MyDoc/MyObject1/title"/> // Pour récupérer des valeurs simples
  
<xsl:for-each select="/MyDoc/MyObject2"> // Pour le parcours de collection

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:n2="urn:hl7-org:v3"
    exclude-result-prefixes="n2 xs xsi xsl">
    <xsl:output method="xml" encoding="UTF-8" indent="yes" />
    <xsl:template match="/">
        <w:document
            xmlns:ve="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:o="urn:schemas-microsoft-com:office:office"
            xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
            xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
            xmlns:v="urn:schemas-microsoft-com:vml"
            xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
            xmlns:w10="urn:schemas-microsoft-com:office:word"
            xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
            xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml">
            <w:body>
            
...
...
...
</w:body>
</w:document>
</xsl:template>
</xsl:stylesheet>

Cette pratique présente un inconvénient, du fait de la création de ce fichier par un programme, le contenu est souvent excessivement verbeux et dénué de toute forme d'intelligence. Pour générer un fichier Word à partir d'une transformation XSL, il vaut mieux comprendre un minimum la logique de ce fichier. Comprendre les balise principales est utile

<w:p> : Sert à commencer un paragraphe
<w:pPr> : Définit les paramètres du paragraphe
<w:rPr> : Définit les paramètres applicables au mot. Un rPr peut-être définit au niveau du wPr Lorsqu'il concerne tous les mots du paragraphe ou dans w:r lorsqu'il concerne un mot seulement
<w:tabs> : Permet de définir les différentes tabulations dans une paragraphe
<w:r> : Définit un groupe de mots
<w:t> : Définit un mot
<w:tab> : Insère une tabulation
<w:tbl> : Une table
<w:tr> : Une ligne (table row)
<w:tc> : Une colonne (table column)
<w:b> : Met le texte en gras
<w:u> : Souligne le texte (Attention il faut préciser le type de soulignement)
<w:customXml element='??'> : Est une balise qui permet de définir des structures de XML comme des information cachées, c'est utile pour structurer le document de manière invisible.

Une fois que le document est constitué, il suffit de refaire un zip et de renommer l'extension .zip en .docx. Si vous compressez l'OpenXML à l'aide de java, il faut faire attention à ce que les entries utilise le caractère '/' et non pas '\', autrement le fichier ne pourra être ouvert par la suite OpenOffice.

JDOM vs DOM et SAX

2009-07-20T08:08:00.000-07:00

La librairie JDOM a l'inconvénient majeur de ne pas être présente dans les APIs JAVA et de ne pas être une norme W3C. Pourtant, même si elle ne propose aucune révolution théorique, cette librairie est plus pratique à utiliser que ses consors SAX et DOM. En faits, SAX et DOM ont été développés pour couvrir être implémenté en C et C++ notamment, JDOM n'ayant pas ses limitations peut se permettre d'être plus intelligente.

Cette API est très sympathique car elle se sert des fonctionnalités de JAVA pour ne plus avoir en tête les considération de consommation de mémoire qui sont souvent problématique dans le cas des fichiers XML. Les performances s'apparentent à celle du SAX et la souplesse est proche du DOM.

Elle possède des fonctionnalités qui s'apparente à XPath (mais en plus simple). JDOM peut-être utilisé pour des transformations de noeuds non prises en compte trivialement par XSL (Déplacements de noeuds, clonages, modification de structure hiérarchiques)

Et pour ceux qui doutent encore, il a été décidé que JDOM sera intégré au futures JDK.
Alors lancez vous !

Exemple de parsing :


SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(xslIs);

Exemple de sérialisation :


XMLOutputter xmlOutputter = new XMLOutputter();
xmlOutputter.output(doc, fos);

Exemple de sérialisation :


XMLOutputter xmlOutputter = new XMLOutputter();
xmlOutputter.output(doc, fos);

Exemple de copie de noeud :


Element cloneElement = (Element) originalElement.clone();
parentElement.addContent(cloneElement);

C'est souvent beaucoup plus simple que XSL dans le cas de transformations complexes !

Configurer maven à travers un proxy

2009-07-03T05:33:00.000-07:00

Voici le fichier de configuration pour passer à travers un proxy

<settings>
<localRepository>d:/repo-maven</localRepository>
  <proxies>
   <proxy>
      <active>true</active>
      <protocol>http</protocol>
      <host>proxy.mycorp.com</host>
      <port>8080</port>
      <nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
    </proxy>
  </proxies>
</settings>

Terminologie de l'informatique

2009-06-26T06:13:00.001-07:00

L'informatique est une industrie relativement récente et la plupart de son vocabulaire a été emprunté à des corps de métier plus anciens. La tendance logomachique du secteur n'est plus à démontrer. En général, le vocabulaire utilisé est abscons et imprécis, il est toujours difficilement compréhensible pour le néophyte. A mon avis, il y a deux raisons à cela :

Le développement du business (Un business est d'autant plus juteux qu'il est occulte) C'est ainsi que les astrologues vivaient grassement il y a quelques siècles.
Un complexe d'infériorité. Le boums de l'informatique a connu une période où les jeunes étaient dominant. Et tout le monde se congratulait d'être cadre, d'être ingénieur. Simplement, il est naturel de crâner un peu quand on est jeune.

MOA :
Maitrise d'ouvrage. Le terme maitrise d'ouvrage vient des métiers du bâtiment. Anciennement, il s'agissait tout simplement du commanditaire de la réalisation. C'est celui qui possède l'argent et gère des budgets.

commanditaires est un terme moins ambigu.

MOE :
Maîtrise d'œuvre vient également du bâtiment. Cet acteur prend la direction technique de la réalisation. La MOE prend en charge la gestion du projet ainsi que la réalisation.
direction de réalisation est un terme moins ambigü

Architecte :
L'architecte est un concepteur. Ce mot est très pompeux, attendu que à l'inverse du bâtiment un architecte peut et doit mettre la main à la pâte dans la réalisation. Il effectue des choix techniques orientant le choix des technologies, il choisi les modes de réalisation, défini le plan d'implantation du système, contraintes du projets. Il y a deux catégories d'architecte :

- Architectes système : Défini les plan d'implantation du des serveurs
- Architecte logiciel : Effectue des choix technique

direction de réalisation est moins ambigu

Gestion de configuration :
La gestion de configuration est une notion empruntée à l'industrie. Ce terme désigne les processus pour gérer le différentes configurations de produits physique. L'informatique a repris ce vocabulaire pour la gestion des sources, mais la maturité aidant il est devenu obsolète de parler de gestion de configuration quand il s'agit de gérer des code sources : appelons un chat un chat.

Le métier :
Le métier représente les concepts propres au commanditaire. La polysémie du mot métier est intrinsèque, mais il s'agit le plus généralement de tout ce qui ne concerne pas la technique informatique.

L'utilisation de l'anglicisme business est stupide car le business en anglais recouvre deux notions : les affaires et le métier. Autant s'en passer

Les beans :
Le bean est du tartalacrème de chez tartalacrème. il fut un temps où tout était bean. Avec le temps, son sens est devenu plus précis : Il s'agit d'une classe possédant des accesseurs et dépourvue de code de traitement.

Appliquer des patchs sur des répertoires

2009-06-21T02:49:00.000-07:00

En ayant modifié un repertoire hors de conf, comment répercuter les modifications sur la conf.

-n pour dry-run (faire le test)
-C pour exlure les fichier de conf

Cette commande pour voir les nouveaux fichiers


rsync -n -r -v -u -C src dst

puis


rsync -r -v -u -C src dst

Effectue vraiment l'opération

Patcher sur un repertoire n'est généralement pas une opératio automatique.

Cette commande pour voir les fichiers à supprimer


rsync -n -r -v --del -C src dst

Puis


rsync  -r -v --del -C src dst

applique la modification

diff permet de créer des patch

patch permet de les appliquer.

Eclipse permet d'appliquer des patch sur des répertoire en entier.

La voie du milieu dans le développement informatique

2009-06-18T02:40:00.000-07:00

Un jour, vous vous êtes peut-être retrouvé, comme moi, piégé dans une querelle surréaliste où deux "experts" s'entretuaient à propos du StringBuffer.append() et de l'opérateur + sur une String.

En voyant la rage et l'énergie dépensée, vous vous êtes peut-être dit comme moi : peut-être que c'est important ? Et puis, vous vous êtes repris : Non, ça ne peut-pas être important ! Mais alors, comment lutter contre le brassage de vent ? Car en luttant pour le bon sens, on s'aperçoit que la voie la plus raisonnable n'est pas la plus facile à défendre. Selon moi, l'industrie informatique est en passe d'atteindre la maturité, mais certains comportements radicaux de son adolescence subsistent.

Pour atteindre la sagesse, il convient de considérer les choses avec du recul. Il ne suffit pas d'être rigoureux, il ne suffit pas d'être couvert par les responsable hiérarchique pour bien travailler. L'intelligence n'est pas une vertue strictement positive, dans le sens ou elle constitue un cheminement logique, c'est au contraire la capacité à s'adapter à toutes les situation qui défini le mieux l'intelligence.

L'organisation typique d'une entreprise de développement informatique est la suivante :

Un bureau des méthodes
Un chef de projet de réalisation
Un architecte technique
Les développeurs

Chacun de ces acteurs sont humains et recherchent à travers leur travail la reconnaissance d'un rôle dans la société. Cet objectif inavoué (et respectable) ne doit pas être oublié pour comprendre des aberrations qu'on rencontre dans la vie des entreprises. Aussi, je voudrais m'attarder à travers l'entreprise sur le sujet tabou des affects et faire de la psychologie appliquée. Les goût qui orientent les vocations de chacun et donc, à tel type de métier correspond un profil psychologique.

Ces acteurs défendent chacun des intérêts propres et déclenchent souvent des conflits d'intérêts, où s'invite le passionel :

Le bureau des méthodes

Le bureau des méthodes a deux objectifs :

Améliorer la maintenabilité : Donner des normes, poser des exigences de qualité.
Améliorer la productivité : Fournir des outils et des frameworks, une configuration standard.

Ces deux vocations sont contradictoires. Pour contrer cet antagonisme de surface, suivre la voie du milieu est la meilleure option, mais c'est aussi la plus difficile.

Parce qu'il s'agit d'orienter subtilement les équipes de développement, pour le bureau des méthode, la qualité de la relation avec les équipe de développement est cruciale. Elle passe essentielement par des échanges importants. Une communication ni trop souple, ni trop dure est la solution. Les mails sont utiles, mais rien ne vaut les moyens plus informels pour se comprendre correctement, le téléphone et les réunions. Dans toutes les entreprises que j'ai connues, il n'en est pas une seule ou la relation entre le bureau des méthode et les équipes de réalisation ai été complétement détendue. Ces frictions sont naturelles et inévitable dans une certaine mesure, mais les conflits ouverts ou larvés sont toujours néfastes. Il faut les éviter à tout prix. Il vaut mieux faire des recommandations que des impositions.

Le travers d'un bureau des méthodes est d'alourdir inconsidérément le processus. Le meilleur moyen de ne pas se couper de la réalité du terrain est d'appliquer à soit même ce qui est imposé dans le développement des projets réels, au sein même de l'équipe méthode.

Le chef de projet

Le rôle d'un chef de projet est :

Optimiser le cout de réalisation
Augmenter le bénéfice

Encore un fois, dans le cas du chef de projet, il faut naviguer entre deux eaux. Ce n'est pas un rôle facile, car il n'est pas strictement borné en terme d'affectation. Un chef de projet ne doit pas s'enliser dans la technique et perdre son pragmatisme. A l'inverse, sombrer dans la bureaucratie et ne plus comprendre le langage des équipe qu'il dirige constitue un autre travers. Un chef de projet doit mesurer les impacts des modifications demandées et ne pas rester dans un langage utilisant seulement tache, reste à faire, quand etc. Sa vision doit être synthétique. Le distance raisonnable est une affaire d'expérience, ni trop loin, ni trop proche.

L'architecte

Le rôle de l'architecte consiste à :

Effectuer des choix techniques
Expliquer et argumenter les solutions

Contrairement au autre rôle, un architecte n'a pas besoin de se préserver d'une schizophrénie. Son rôle est tout à fait positif et requiert essentielement de la pédagogie.
Un architecte technique tend à concevoir ses projets à partir de sa seule expérience. Ce n'est pas mauvais en soit, mais cela conditionne l'hermétisme à d'autres solutions plus pragmatiques. Il faut éviter de sacraliser sa propre expérience. Et puis, c'est une mauvaise communication de commencer à présenter ses solutions par : "Croyez-en mon expérience". La capacité de remise en cause est fondamentale pour éviter les tentacules de la déréliction. Mieux vos décliner patiemment les avantages de votre solution.

Le développeur

Le rôle d'une développeur est de produire un programme conforme à ce qui lui a été demandé.
Le travers d'un développeur est de rechercher la solution immédiate à ses problèmes, sans se préoccuper du long terme. Pour bien faire, il faut penser à ses successeurs. L'inverse peut également se produire, lorsqu'un développeur souhaite utiliser une technologie uniquement pour progresser dans ses connaissances.

Quelque soit votre place dans l'organisation, la meilleure option est de suivre la voie du milieu.
La voie du milieu doit avant tout éviter les écueils typiques :

- Auto référence :
Avec l'avènement d'internet, les experts techniques (le bureau des méthodes) ont tendance à prendre pour argent comptant ce qui est affirmé sur les experts. Ce genre de pratique est tellement généralisé, que les publications d'experts reprennent souvent ce qu'il ont lus d'autres experts : La boucle est bouclée. Cette auto-référence décorelle les vérités d'internet de celle du monde réel.

- Généralisation de l'automatisation :
Dans la recherche de la qualité, l'utilisation des outils fournissant des indicateurs s'est généralisée. De plus en plus fréquement, la qualité d'un code est appréciée suivant des paramètres automatique. Il est bon de rappeler, tout ce qui est automatique se substitue rarement à l'intelligence. La conformité checkstyle n'est en rien la garantie d'un "bon" code. Rien ne vaut un audit de code utilisant de la matière grise.

- Complexité inutile :
L'informatique s'applique toujours à la modernisation. Tout les acteurs ont économiquement des intérêts à promouvoir la nouveauté. Confondre la nouveauté avec l'efficacité est un mensonge défendu à tous les niveaux du secteur informatique. C'est pourtant clairement faux, ne l'oubliez pas. La plupart des projets de modernisation visent à améliorer l'efficacité. C'est seulement en atteignant cet objectif que vous ferez un client heureux.

- Jargonnage :
L'architecture en informatique est un concept flou. Généralement, il s'agit de conception sous toute ces formes : du découpage, des choix techniques, mais ce peut-être aussi des choix d'organisation qui concerne la gestion de projet.

Ce statut incommode manque parfois de respectabilité. Selon moi, le soucis principal des architectes est de se positionner correctement pour avoir une autonomie importante. Il existe deux manières pour ce faire :

la pédagogie (qui est lente)
La rétention d'information et le dirigisme envers le développeur

Bien évidement la pédagogie nécessite plus de patience mais elle paie mieux sur le long terme.

Méfiez vous systématiquement de quelqu'un qui utilise trop d'acronymes. Comme dit Pascal, ce qui se conçoit bien s'énonce clairement.

- Exploitation de la peur :
La peur est utilisée pour saigner les clients. Elle sert à vendre des "optimisations" à priori. Alourdissant inutilement l'architecture. Lorsqu'une optimisation est proposée, elle doit correspondre à une volumétrie réelle. Si vous n'êtes pas google, il y a de fortes chances que les meilleures réponses aux problèmes de performance consistent à modifier les processus.

La peur intervient également dans le domaine de la sécurité informatique. Ce n'est pas un hasard si les audits de sécurité sont parmi les plus chers qui soient. Ils font intervenir uniquement des experts. Rappelez-vous simplement ceci, aucune sécurité n'est infaillible. Un chantier de sécurisation sert à placer curseur plus ou moins haut. Si une faille est découverte, cela ne suffit pas à démontrer que le système est mauvais, l'inverse est évidement vrai aussi. la sécurité n'est pas une mesure binaire.

Ouvrir un document en java

2009-06-16T08:20:00.000-07:00

Pour ouvrir un document sans préciser entièrement la ligne de commande.

Ceci permet de déléguer la responsabilité d'assigner un programme à un type de document. Pour ouvrir un PDF.

L'article source

Sous windows :


public class ShowPDF {
public static void main(String[] args) throws Exception {
Process p = 
Runtime.getRuntime()
.exec("rundll32 url.dll,FileProtocolHandler c:/pdf/mypdf.pdf");
p.waitFor();
}
}

Sous linux :


public class ShowPDF {
public static void main(String[] args) throws Exception {
Process p = 
Runtime.getRuntime()
.exec("mimopen  c:/pdf/mypdf.pdf");
p.waitFor();
}
}

Pour éditer l'association des fichiers modifier ce fichier :
/usr/share/application-registry/gnome-vfs.applications

Appfuse pour le développement rapide d'application JAVA

2009-06-12T02:19:00.000-07:00

Appfuse aide au développement rapide des applications web java à l'aide de technologies open source.

A l'aide de maven vous pouvez simplement initiez un projet de par la commande mvn archetype:generate et selectionner :

appfuse-basic-jsf
appfuse-basic-spring
appfuse-basic-struts
appfuse-basic-tapestry
appfuse-core
appfuse-modular-jsf
appfuse-modular-spring
appfuse-modular-struts
appfuse-modular-tapestry

Les avantages :
Le développement est accéléré par une gestion des utilisateurs et des rôles déjà implémentée. Elle nécessite peu d'adaptation pour se conformer des cas d'utilisations réels d'une application de gestion.
Les controlleurs de base sont assez souples pour se conformer à toutes les navigations rencontrées dans les application de gestion.
Les DAO et manager Générique accélère notablement le cas basique d'édition d'un fomulaire.
L'adaptation graphique est peu couteuse.

Les inconvénients :
Les prototypes proposés par maven sont assez mauvais :
Le développement avec l'IDE eclipse est difficile à initialiser pour fonctionner avec WTP.
Le pom est pollué par tout un tas de fonctions qui ne sont pas nécessaires quand l'objectif est la rapidité. L'enrichissement progressif aurait été préférable.
Le mécanisme de properties est lourd et ne fonctionne bien qu'avec maven, voir lourdingue et freine la rapidité de développement.
Le prototype maven utilisant la dépendance de war est très peu lisible et n'apporte pas grand chose.

En réalité, le travail avec appfuse pour une petite application commence par les suppression des fonctions ne concernant pas directement la productivité : checkstyle, PMD, aspect etc.

La documentation est encore légère et manque d'exemples complets.

Conclusion :

Appfuse n'est pas encore un RAD, il n'est pas révolutionnaire non plus. Le vrai problème de appfuse est la manière dont il est exploité avec maven. Cependant, il peu constituer la première inspiration pour créer un framework maison. Les archétypes maven peuvent difficilement être considérés comme un framework RAD.

A mon sens, les archetypes fournis souffrent d'une conception trop théorique. Ces handicaps sont particulièrement gênants lorsqu'il s'agit d'être rapidement productif. Néamoins, après quelques adaptations, ces prototypes peuvent remplir leurs objectifs de rapidité.

Effectuer une compie de synchronisation

2009-02-26T07:05:00.001-08:00

La commande rsync permet d'effectuer une copie de synchronisation sous Linux. Cette commande permet notamment d'effectuer des backup de vos données (Musique, films, images etc.) mais elle peut également servir à synchroniser les codes sources de vos programmes sans utiliser de gestionnaire de configuration.

Il existe de nombreuses options que l'on peut consulter à l'aide de man.

Exemples :

Copie d'une arborescence entière :


rsync -rvu /srcdir /dstdir

Cette commande permet de copier les fichiers et leur arborescence de /srcdir vers /dstdir
-r pour récursif
-v pour verbose
-u pour update (Autrement les fichiers qui n'ont pas été modifié sont recopiés)

L'option -n permet de simuler l'opération en listant les modifications qui seront effectuées.

Copie des fichiers L* et leur arborescence dans vers /dstdir :


rsync -rvu -f"+ */"  -f"+ L*" -f"- *" /srcdir /dstdir

Pour copier la structure de repértoire seulement


rsync -av --include='*/' --exclude='*' src dest

Pour synchroniser un projet maven à partir d'un code source modifié sur une machine n'ayant pas accès au gestionnaire de configuration.


rsync -rnvu --delete -c  --exclude=.svn --exclude=target/ /elsewhere/mydistantproject/ /home/myworkspace/mylocalproject/

Convertir des fichiers stéréo en mono

2009-02-26T05:22:00.000-08:00

Le logiciel sox sous linux permet d'effectuer une conversion de stéréo vers mono.
Il permet également de doser le mixage.
Pour ne recopier que le canal gauche
sox -c1 input.mp3 output.mp3 remix 1

Pour ne recopier que le canal droit
sox -c1 input.mp3 output.mp3 remix 2

Pour transformer en mono
sox -c1 input.mp3 output.mp3 remix -

Pour effectuer le transformation de manière globale.

find *.mp3 -exec sox -c1 '{}' 'left/{}' remix - \;

Comment parcourir récursivement un répertoire pour appliquer des traitement en C

2009-02-25T08:51:00.000-08:00

Lorsque l'on veut appliquer un traitement à des fichiers en parcourant l'arborescence. Il y a la possibilité d'utiliser la commande find associé à - exec.

Voici quelques exemples du monde réel world FIND usage


Copie dans un répertoire
find / -type f -name *.jpg  -exec cp {} . \;
find /home/hudson/repertoire-data/ -type f -regex ".*ARTICLE_O.*" -exec echo {} \;
find /home/hudson/repertoire-data/ -type f -regex ".*ARTICLE_[^O].*" -exec echo {} \;
find . -type f -size +10000 -exec ls -al {} \;
Récherche des fichiers accédés il y a un jour
find . -atime +1 -type f -exec mv {} TMP \; 
find . -name "-F" -exec rm {} \;   # a script error created a file called -F 
find . -exec grep -i "vds admin" {} \;
find . \! -name "*.Z" -exec compress -f {} \;
find . -type f \! -name "*.Z" \! -name ".comment" -print | tee -a /tmp/list
find . -exec chmod 775 {} \;
find . -user xuser1 -exec chown -R user2 {} \;
find . -exec grep PW0 {} \;
find . -exec grep -i "pw0" {} \;
find . -atime +6
find . -atime +6 -exec ll | more
find . -atime +6 -exec ll | more \;
find . -name auth*
find . -exec grep -i plotme10 {} \;
find . -ls -exec grep 'PLOT_FORMAT 22' {} \;
find . -print -exec grep 'PLOT_FORMAT 22' {} \;
find . -print -exec grep 'PLOT_FORMAT' {} \;
find . -print -exec grep 'PLOT_FORMAT' {} \;
find ./machbook -exec chown 184 {} \;
find . \! -name '*.Z' -exec compress {} \;
find . \! -name "*.Z" -exec compress -f {} \;
find /raid/03c/ecn -xdev -type f -print
find /raid/03c/ecn -xdev -path -type f -print
find / -name .ssh* -print | tee -a ssh-stuff
find . -name "*font*"
find . -name hpmcad*
find . -name *fnt*
find . -name hp_mcad* -print
find . -grep Pld {} \;
find . -exec grep Pld {} \;
find . -exec grep Pld {} \;
find . -exec grep PENWIDTH {} \; | more
find . -name config.pro
find /raid -type d -name ".local_sd_customize" -print
find /raid -type d -name ".local_sd_customize" -ok cp /raid/04d/MCAD-apps/I_Custom/SD_custom/site_sd_customize/user_filer_project_dirs {} \;
find /raid -type d -name ".local_sd_customize" -exec cp /raid/04d/MCAD-apps/I_Custom/SD_custom/site_sd_customize/user_filer_project_dirs {} \;
find . -name xeroxrelease
find . -exec grep xeroxrelease {} \;
find . -name xeroxrelease
find . -name xeroxrelease* -print 2>/dev/null
find . -name "*release*" 2>/dev/null
find / -name "*xerox*" 2>/dev/null
find . -exec grep -i xeroxrelease {} \;
find . -print -exec grep -i xeroxrelease {} \;
find . -print -exec grep -i xeroxrelease {} \; > xeroxrel.lis
find . -exec grep -i xeroxrel {} \;
find . -print -exec grep -i xeroxrel {} \;
find . -print -exec grep -i xeroxrel {} \; | more
find /raid/03c/inwork -xdev -type f -print >> /raid/04d/user_scripts/prt_list.tmp
find . -exec grep '31.53' {} \;
find . -ls -exec grep "31/.53" {} \; > this.lis
find . -print -exec grep "31/.53" {} \; > this.lis
find . -print -exec grep 31.53 {} \; > this.lis
find . -exec grep -i pen {} /;
find . -exec grep -i pen {} \;
find . -print -exec grep -i pen {} \; | more
find . -exec grep -i pen {} \;
find . -atime +6 -exec ll | more \;
find . -atime +6 -exec ll \;
find . -atime +6 -exec ls \;
find . -atime +30 -exec ls \;
find . -atime +30 -exec ls \; | wc -l
find . \! -name '*.Z' -exec compress -f {} \;
find . -name 'cache*' -depth -exec rm {} \;
find . -name 'cache*' -depth -print | tee -a /tmp/cachefiles
find . -name 'cache[0-9][0-9]*' -depth -print | tee -a /tmp/cachefiles
find . -name 'hp_catfile' 'hp_catlock' -depth -print | tee -a /tmp/hp.cats
find . -name 'hp_catfile' -name 'hp_catlock' -depth -print | tee -a /tmp/hp.cats
find . -name 'hp_cat*' -depth -print | tee -a /tmp/hp.cats
find . -name 'hp_cat[fl]*' -depth -print | tee -a /tmp/hp.cats
find /raid -name 'hp_cat[fl]*' -depth -print
find . \! -name '*.Z' -exec compress -f {} \;
find . -name '*' -exec compress -f {} \;
find . -xdev -name "wshp1*" -print
find . -xdev -name "wagoneer*" -print
find . -name "xcmd" -depth -print
find /usr/contrib/src -name "xcmd" -depth -print
find /raid -type d -name ".local_sd_customize" -exec ls {} \; 
find /raid -type d -name ".local_sd_customize" \
   -exec cp /raid/04d/MCAD-apps/I_Custom/SD_custom/site_sd_customize/user_filer_project_dirs {} \;

L'inconvénient de la méthode find est qu'elle passe par l'interpréteur de commande pour lancer le shell ce qui peut-être problématique lorsque l'on souhaite traiter des fichiers ayant des noms comportant des espaces, guillemets, parenthèse etc.

La seconde solution est de faire un programme C pour appliquer son traitement. La librairie ftw adresse spécialement ce type de problème, elle fonctionne comme la commande find.

Ses paramètres sont
* Le chemin de départ de la récursion
* La méthode à appeler pour chaque élement (Le nom peut varier mais elle doit retourner un entier et avoir trois arguments.
int nomdemethode(const char *path, const struct stat *ptr, int flag))

Voici un exemple :

#include <ftw.h>
#include <stdio.h>

int process(const char *path, const struct stat *ptr, int flag)
{
 printf("Found\n path:%s\nflag%d\n", path, flag);
 return 0;
}

int main(int argc, char *argv[]) {
 if(argc == 1){
  ftw(".", process, 1);
}
 else{
  ftw(argv[1], process, 1);
}
 return 0;
}

Exemple d'utilisation :

Je voulais appliquer un traitement audio à de nombreux fichiers par le biais de la commande sox, malheureusement ce programme n'avait pas de fonction qui permettait d'effectuer des traitements par lots.

Les noms de fichiers comportaient aussi de nombreux caractères spéciaux qui empêchaient l'utilisation de la commande find. J'ai adapté le source du programme.

- Renommer la méthode main de sox par une méthode ancienmain
- Utiliser la méthode main du type présenté plus haut
- Créer une méthode appelée à chaque fois que ftw rencontre un nouvel élément on l'appelle process.

int process(char *dirname, const struct stat *status, int type){
                                if(!(type == FTW_F && strstr(dirname,".mp3")!=NULL&& strstr(dirname,"/L-")==NULL)){ 
                                    return 0;
                                }
                                
                                // Ici nous construisons les paramètres qui servent pour appeler l'ancien main. 
                                                            
                                
                             char * params[6]; 
                  char nom_transforme[200];
                  struct stat s; 
                  nom_transforme[0]=0;
                  params[0]="sox";
                  params[1]="-c1";
                  // ...
                   params[4]="remix";
                  params[5]="1";
                  
                  /*
                    Les programmes ne sont généralement pas fait pour fonctionner en batch
                    aussi, il est nécessaire d'initialiser les variable globale à chaque appel.
                    Ce sont celle qui sont en dehors de toute méthode. 
                **/
                mavarglobale1=0;
                mavarglobale2=1;
                            ...
                                mavarglobale3 = NULL;
                                mavarglobale4  = 0;
                                
                        // Appel de l'ancien main
                ancienmain(6,params);
}

Il ne s'agit clairement pas d'un controunement facile, et la volumétrie des fichiers doit clairement compenser l'effort de programmation par rapport à un appel de find.

Montage Samba Mandriva

2009-02-25T05:07:00.000-08:00

Comment monter un partage samba en ligne de commande sous mandriva.

Installer le rpm mount-cifs

taper
mount.cifs //Monserver/monpartage /mnt/monpointdemontage -ouser=monuser

Utilisations des threads

2009-02-20T01:58:00.000-08:00

Il existe deux techniques d'utilisation des thread en JAVA :

* Implémenter l'interface Runnable
* Etendre la classe thread.

Dans l'optique de faire un code robuste, je recommande d'implémenter l'interface Runnable, elle évite de se perdre dans la profusion de méthodes offertes par la classe Thread.

Les threads servent à paralléliser les tâches. Deux opérations clés sont importantes.

* Le départ
* La synchronisation (jointure)

Le plus délicat est de comprendre l'utilisation du wait et du notify. Pour être utilisé le wait et le notify doivent être placé sur la même classe (Ici le ThreadGroup)



Ce bloc lance 25 threads

// Ici nous construisons sans les déclencher tous les thread dont nous avons besoins
List<thread> threads = new ArrayList<thread>();
ThreadGroup threadGroup = new ThreadGroup("MyThreadList");
for (int i = 0; i < thread =" new" thread =" new"> 0) {
   System.out.println("Threads restants : " + threadGroup.activeCount());
   // Attente d'une nçotification
   threadGroup.wait();
}
}

Voici l'implémentation de Runnable


public class MyThread implements Runnable {

public MyThread(ThreadGroup tg) {
       threadGroup = tg;
}

public void run() {
System.out.prinln("Effectue le traitement");

// Ici le ThreadGroup est notifié
synchronized (threadGroup) {
       // Notification du parent
       threadGroup.notify();  
}
}

Encodage et maven

2009-02-19T06:29:00.000-08:00

Si l'on assemble les projets maven sur des machines ayant des encoding différents (par exemple une application développée sous windows et assemblé sur LINUX UTF-8), il peut y avoir des problèmes d'encodage de fichier se manifestant par caractères inconnu aparaissant à l'écran.

Pour ne pas avoir de soucis, il est nécessaire de préciser l'encoding du compilateur et celui de l'assembleur ressources dans le descipteur de projet pom.xml .

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<encoding>ISO-8859-1</encoding>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin
</artifactId>
<configuration>
<encoding>ISO-8859-1</encoding>
</configuration>
</plugin>

Traiter les espace dans les lignes de commande

2009-01-26T05:32:00.000-08:00

Le traitement des espaces dans les lignes de commande peut-être délicat dans les lignes de commande linux.

mkdir convert/
ls *.dat|
while read i
do
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
echo sox -c1 $i convert/$i remix 1
done

Faire un appender suffixé par la date

2008-12-16T02:21:00.000-08:00

Cette classe permet de faire un appender qui suffixe la date.

package myprog.util;
import java.text.SimpleDateFormat;
import java.util.Date;
 
import org.apache.log4j.FileAppender;
 
public class DateFileAppender extends FileAppender {
 
        private String datePattern = "yyyyMMddhhmm";
        
        public void setFile(String strFile) {
                String strDate;
                SimpleDateFormat sdf;
                
            if (datePattern!=null && strFile!=null) {
                sdf = new SimpleDateFormat(datePattern);
                strDate = sdf.format(new Date());
                fileName = strFile.replaceAll("%date%", strDate);
              } else {
                  System.err.println("Either File or DatePattern options are not set for appender [" + name + "].");
              }
        }
 
        public String getDatePattern() {
                return datePattern;
        }
 
        public void setDatePattern(String datePattern) {
                this.datePattern = datePattern;
        }
}

Pour l'utiliser dans le fichier log4j

log4j.appender.F1=myprog.util.DateFileAppender
log4j.appender.F1.File=log/extract-generated-%date%.log
log4j.appender.F1.layout=org.apache.log4j.PatternLayout
log4j.appender.F1.layout.ConversionPattern=%m%n

Utiliser XStream rapidement

2008-12-05T05:10:00.000-08:00

Méthodes importantes

Definir une classes


alias("MY_TABLE", MyType.class);

Definir un champ


aliasField("MY_TABLE", MyType.class, "fieldName");

Definir un attribut


aliasAttribute(MyType.class, "fieldName","attribute-name");

Ignorer des champs


omitField(CaptureSacapt.class, "mareeId");

Questions diverses

Utiliser un format de date compatible avec les XSD


registerConverter(new ISO8601DateConverter());

Il est nécessaire pour ceci d'ajouter à son fichier POM


<dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>1.5.2</version>
</dependency>

Changer l'ordre des champs

La manière la plus simple de changer l'ordre d'apparition des balise dans le XML généré est tout simplement de changer l'ordre des champs à l'intérieur de la classe.

L'autre méthode consiste à se servir d'un trieur de champs.

SortableFieldKeySorter sorter = new SortableFieldKeySorter();
sorter.registerFieldOrder(MyType.class, 
new String[] { "firstToSerialize", 
"secondToSerialize", 
"thirdToSerialize" }
);
xstream = new XStream(new Sun14ReflectionProvider(new FieldDictionary( sorter)));

Les éléments nuls

Il n'existe pas de manière simple de traiter les chaine vide comme des nulles. Il est nécessaire d'implémenter un convertisseur et de l'enregistrer.

Validation par XSD

Un XML est validé par XSD

SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setNamespaceAware(true);
spf.setValidating(true);
SAXParser sp = spf.newSAXParser();
sp.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
InputStream schemaIs = getClass().getResourceAsStream("/my-validator.xsd");
sp.setProperty(JAXP_SCHEMA_SOURCE, schemaIs);
XSDHandler handler = new XSDHandler();
sp.parse(file, handler);

Generators in Hibernate Annotations

2008-10-28T05:47:00.000-07:00

Identity generator in hibernate

@Id 
@GeneratedValue (strategy=GenerationType.IDENTITY)
@Column(name = "REJ_CDN")
int id;

* Tested with Sybase

Increment generator in hibernate

@Id
@GeneratedValue(generator = "autoincrement")
@GenericGenerator(strategy = "increment", name = "autoincrement")
@Column(name = "MYID")
Integer id;

* Tested with Sybase

AJP13 avec apache

2008-10-24T07:17:00.000-07:00

Pour router votre serveur apache vers le serveur tomcat, il faut utiliser un proxy, apache délègue sa requête au serveur tomcat. Ce mode de fonctionnement permet surtout de faire du load balancing et, lorsqu'il s'agit de servir des fichiers, utiliser la code natif plus performant de apache.

Après avoir installé et déclarés le module proxy_ajp_module dans le fichiers httpd.conf :

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_connect_module modules/mod_proxy_connect.so
LoadModule proxy_ftp_module modules/mod_proxy_ftp.so
LoadModule proxy_http_module modules/mod_proxy_http.so
LoadModule proxy_ajp_module modules/mod_proxy_ajp.so

Ajouter dans le fichier httpd.conf les lignes suivantes

Include conf/vhosts.d/*.conf
<Location /wiki >
 AuthType Basic
 AuthName "Restricted Files"
 AuthUserFile /etc/apachepasswd
 Require user wiki
 ProxyPass ajp://localhost:8009/JSPWiki
 ProxyPassReverse ajp://localhost:8009/JSPWiki
 allow from all
</Location>
<Location /gestion >
 ProxyPass ajp://localhost:8009/gestion
 ProxyPassReverse ajp://localhost:8009/
 allow from all
</Location>


Autrement, il est aussi possible de créer un fichier worker.properties 
# worker "worker1" will talk to Tomcat listening on machine www.x.com at port 8007 using 2 lb factor
worker.list=worker1
worker.worker1.host=myhost
worker.worker1.port=9009
worker.worker1.lbfactor=2


# Update this path to match your conf directory location (put workers.properties next to httpd.conf)
JkWorkersFile /etc/httpd/conf/worker.properties
# Where to put jk shared memory
# Update this path to match your local state directory or logs directory
JkShmFile     /var/log/httpd/mod_jk.shm
# Where to put jk logs
# Update this path to match your logs directory location (put mod_jk.log next to access_log)
JkLogFile     /var/log/httpd/mod_jk.log
# Set the jk log level [debug/error/info]
JkLogLevel    info
# Select the timestamp log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
# Send everything for context /examples to worker named worker1 (ajp13)
JkMount  /ft-jobs/* worker1

Changer l'URL

Pour configurer de manière centralisée les applications, il est possible d'utiliser un apache frontal et de repartir les adresses vers des serveurs mandatataires, apache agit donc comme un proxy et il suffit d'ajouter la ligne suivante dans le fichier httpd.conf
Par exemple si la machine vm04 est le frontal et que le serveur hudson est sur la vm04, il suffit d'ajouter la ligne suivante au fichier httpd.conf


ProxyPass   /hudson/  http://vm04:8080/hudson/



On accedera à hudson par l'url http://vm01/hudson/



Faire du load balancing

Solution n°1

<Location /jonas>
ProxyPass   balancer://mycluster/
ProxyPassReverse  balancer://mycluster/
Allow From All
</Location>


<Proxy balancer://mycluster>
BalancerMember  ajp://localhost:9009/myapp
BalancerMember  ajp://localhost:8009/myapp
</Proxy>


Solution n°2



ProxyPass   http://localhost/myapp/
ProxyPassReverse /myapp/
Allow From All


JkWorkersFile /etc/httpd/conf/worker.properties
JkShmFile     /var/log/httpd/mod_jk.shm
access_log)
JkLogFile     /var/log/httpd/mod_jk.log
JkLogLevel    info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
JkMount  /myapp/* worker1



No Dialect mapping for JDBC type: -1
2008-10-21T05:40:00.000-07:00
org.hibernate.MappingException: No Dialect mapping for JDBC type: -1

Was provoked by :

  String query = "SELECT * FROM MYTABLE WHERE MYID=? "
+ "AND MYCRITERIA >= ?";
SQLQuery sqlQuery;
sqlQuery = session.createSQLQuery(query);
sqlQuery.setString(0, code);
sqlQuery.setDate(1, date);
List<string> ports = sqlQuery.list();


The cause was I could not to use the *, I had to specify each field instead.


How to copy a file on webdav using common-httpclient ?
2008-10-21T02:06:00.000-07:00
Webdav technology allow sharing files with internet. WebDav is a filesytem interface relying on http protocol, a non transactionnal. Webdav manages files whithout locking and work using a versionning system in order to continue working for multiple users. A tricky mecanism for holding concurrent versions lay behind the scene, but if you plan to use WebDav like you'd use a samba filesytem, you may not care understanding  of the hidden processes. 

If your on a local network, you'd still prefer more standard file system for convenience.

In java, you can use the generic http client commons-httpclient to put your files on a webdav server. I give you a sample code that let you create a file on the server and then DELETE it. Somme more sophisticated operations can be performed with the jackrabbit-webdav library, it will provide you with more operations. 

HostConfiguration hostConfig = new HostConfiguration();
hostConfig.setHost("targetserver");
HttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
HttpConnectionManagerParams params = new HttpConnectionManagerParams();
int maxHostConnections = 20;
params.setMaxConnectionsPerHost(hostConfig, maxHostConnections);
connectionManager.setParams(params);
HttpClient client = new HttpClient(connectionManager);
Credentials creds = new UsernamePasswordCredentials("username","password");
client.getState().setCredentials(AuthScope.ANY, creds);
client.setHostConfiguration(hostConfig);
PutMethod putMethod = new PutMethod(
                    "http://targetserver:8080/webdav/targetfilename");
FileInputStream is = new FileInputStream("myfile.pdf");
InputStreamRequestEntity requestEntity = new InputStreamRequestEntity(is);
putMethod.setRequestEntity(requestEntity);
client.executeMethod(putMethod);
System.out.println(putMethod.getStatusCode() + " "
                    + putMethod.getStatusText());


You could have to sort of status code :
201 Created (A file has been created)
204 No data(The http response has no data, but the operation has performed correctly)

And to delete a file :


DeleteMethod deleteMethod = new DeleteMethod(
                    "http://targetserver:8080/webdav/targetfilename");
client.executeMethod(deleteMethod);
System.out.println(putMethod.getStatusCode() + " "
                    + putMethod.getStatusText());

Démarrage des programmes au boot

2008-10-14T08:41:00.000-07:00

Le fichier /etc/initab définit le niveau désiré.

3: Sans écran, multiutilisateur, cela permet un demarrage plus rapide et économise les ressources nécessaire pour le X. Utile pour un serveur.
5: Avec le démarrage du mode graphique, c'est le mode par défaut.

Pour démarrer un programme automatiquement :

Créer le fichier de démarrage dans /etc/rc.d/rcX.d/ ou X est le niveau du démarrage.

Pour le démarrage, il faut préfixer le nom du fichier de S et donner un numéro de séquence.

Pour l'extinction, il faut préfixer le nom du fichier de K et donner un numéro de séquence.

Ne pas oublier si le fichier .depend.start de renseigner les dépendances.

Créer la metrologie à l'aide de maven

2008-10-08T05:12:00.000-07:00

Le pluggin javancss de paven permet de calculer les métriques pour un projet. Notamment, cela permet de voir quel ration de code a été commenté.

mvn javancss:report

NCSS est le nombre d'instructions, ces dernières sont spécifié par une norme, grossièrement cela correspond au nombre de ';' et de '{'

2766 est le nombre d'instruction du projet

Programm NCSS : le nombre d'instruction total
NCSS average : le nombre d'instruction moyen par classes
CCN : la complexité cyclomatique
Javadocs average : Le nombre de ligen de commentaire par classe.

Program NCSS	NCSS average	CCN average	Javadocs average
2,766.00	3.86	2.02	0.46

Astuces de backup sur Ubuntu et autres LINUX

2008-10-03T02:32:00.000-07:00

Pour nettoyer automatiquement des répertoire de backup des fichiers top anciens

Mettez en cron la commande :

find  /var/backupreposvn/ -atime +60 -type f|xargs rm -f

Pour créer un backup de votre NAS sur votre ordinateur en ayant une gestion des backups trop ancien :


export BACKUPDIR=$HOME/backup/
mkdir $BACKUPDIR
export SRCFILE=$HOME/backup/`date +%Y%m%d`.tgz
tar -cvzf $SRCFILE $HOME/.gvfs/documents\ sur\ ls-wsglbc3/
export COMBIEN=`ls $BACKUPDIR|wc -l`
if [[ $COMBIEN>3 ]]
then 
   find $HOME/backup/ -mtime +30 -exec rm -f {} \;
else
  echo "Pas de fichier à supprimer"
fi

My Sql


mysqldump -uroot -pjt ft_jobs_val|gzip >/var/backup/ft_jobs_val_`date +%Y%m%d`.dump.gz
mysqldump -uroot -pjt ft_jobs_val_int|gzip >/var/backup/ft_jobs_val_int_`date +%Y%m%d`.dump.gz
mysqldump -uroot -pjt jira1|gzip >/var/backup/ft_jobs_jira1_`date +%Y%m%d`.dump.gz
mysqldump -uroot -pjt jira2|gzip >/var/backup/ft_jobs_jira2_`date +%Y%m%d`.dump.gz
find /var/backup/ -mtime +30 -exec rm -f {} \;

Ce script doit être lancé à chaque démarrage de votre session.

Compiler subversion à partir des sources

2008-10-02T07:21:00.000-07:00

Sous linux :
Telecharger et installer openSSL
http://www.openssl.org/source/

./config --prefix=/usr/

Downloader les sources sur http://subversion.tigris.org

Dezipper

Downloader neon sur http://www.webdav.org
Downloader apr sur http://apr.apache.org
Downloader apr-util sur http://apr.apache.org

Dezipper ces trois projet et deplacez les dans dans le projet subversion

mv /home/myhome/apr-util-XXX/ /home/myhome/subversion-XXX/apr-util/
mv /home/myhome/apr-XXX/ /home/myhome/subversion-XXX/apr/
mv /home/myhome/neon-XXX/ /home/myhome/subversion-XXX/neon/

./configure --prefix=/usr

make install

Effectuer une requête simple à l'aide d'Hibernate

2008-10-02T06:31:00.000-07:00

Hibernate, même s'il est particulièrement à l'aise sur les problème d'informatique de gestion (Lecture/Modification d'enregistrements), ne peut se substituer à toutes les utilisations qui sont faite lors de SQL.

C'est particulièrement vrai lorsqu'on se sert de fonctions statistique, telle que SUM( ) ou COUNT(*) Dans ces cas une requête simple est préférable. Hibernate offre la possibilité de faire des requêtes simples par la fonction createSQLQuery("SELECT SUM(MACOL) FROM MATABLE").

Dans ce cas, inutile de "voler" la connexion hibernate pour s'en servir à sa place pour se servir des APIS fournies par JAVA, mieux vaut se servir des APIS hibernate.

Voici un exemple :

SQLQuery query = session
    .createSQLQuery(
"SELECT count(*) FROM MATABLE WHERE MACOL1=? AND MACOL2=?");
query.addScalar("NOMBRE", Hibernate.FLOAT);
query.setDate(0, dateFinMois);
query.setInteger(1, commande.getId());
Float consommeEnFinDeMois = (Float) query.list().get(0);

L'utilisation de la fonction query.setScalar permet de typer la réponse.
query.setInteger(0,x) permet de fournir des paramètres à la requête.

Changer le nom de machine

2008-09-23T06:35:00.000-07:00

Dans le fichier /etc/rc.sysinit, positionner la variable HOSTNAME

Problème étrange de tomcat

2008-09-09T01:11:00.000-07:00

java.lang.NoClassDefFoundError: javax/servlet/ServletContextListener
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:620)
at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124)

catalina.sh debug corrige le problème.

taper run par la suite.

Tracer les jars depuis lesquels sont chargées les classes

2008-09-08T08:50:00.000-07:00

-verbose:class

Ganymede et maven

2008-08-28T05:19:00.000-07:00

Pour utiliser Ganymede et maven, il est nécessaire d'utiliser la version 1.5 ou 2.0 de wtp :

mvn -Dwtpversion=1.5 eclipse:eclipse

Ou bien il est possible de le préciser dans le fichier settings.properties

<profile>
<id>dev</id>
<properties>
    <wtpversion>2.0</wtpversion>
</properties>
</profile>

Recommandation de codage JAVA

2008-08-25T07:21:00.001-07:00

Utilisation des outils

Formatage du code

Sous eclipse :
Ctrl+Shift+F :
permet de formatter le code. Cette commande devrait être lancée avant le commit, de sorte à ce que quelqu'un qui passe cette commande soit toujours capable de reconstituer les changements qui se sont produits par l'historique.
Ctrl+Shift+O :
Supprime les imports inutiles

Checkstyle

Effectue une vérification du style d'un code. Un plugin checkstyle est utilisable sous eclipse il effectue parfois de bonnes suggestions, mais il est souvent un peu trop sévère. S'en inspirer seulement.

Programmation

Codage

Les noms de classe et d'interface

Un nom de classe doit éclairer sur sa fonction. Les noms comportant Handlers, utils et Manager sont à utiliser avec parcimonie, car il ne sont pas concret. Les éviter dans la mesure du possible, si toutefois le besoin était réel.
- Handler est à utilisé pour effectuer des manipulations sur un objets.
- Manager : conventionnellement un manager possède le pouvoir de création des objets qu'il manage (A la différence des handlers.)
- Util : ne doit pas être utilisé pour désigner quelque chose d'utile (Normallement tout ce qui est programmé est utile), mais il doit désigner quelques chose de factorisable pour un groupe de classes (Le plus souvent ce sera le projet). Ce genre de chose s'applique par exemple au logs, au IO et chaque concept très général de l'informatique.
- Helper : même si on le retrouve Helper et Util recouvrent la même utilisation. Il faut choisir l'un ou l'autre.
Les interfaces prennent le nom sans aucun suffixe, ni préfixe
Les implementations se trouvent dans des package différents que les interfaces.
Le rôle fonctionnel est à mettre avant la fonction technique :
Exemple :
AidaService est préferable à ServiceAida

Les méthodes

Le nom de la méthode doit donner une idée de ce qu'elle fait.
Elles commencent par un minuscule.

Ne pas utiliser les _ pour les noms de méthode
Séparer deux mots en utilisant une majuscule
Une méthode doit effectuer un traitement qui se rapporte à son nom (Ce nom ne doit pas être trop générique s'il n'existe pas d'interface qui impose ce nom)
Elle ne doivent pas être trop longue(moins de 60 lignes)

Noms des variables

Ne pas utiliser les _ pour les noms de variables.
La séparation de deux mots se fait à l'aide de majuscules.
Les noms de variables indiquent plutôt le contenu d'une variable plutôt que sa fonction technique.

Par exemple :

Si une méthode retourne un dossier, n'est pas un bon nom "result" pour désigner le retour d'une méthode, il vaut mieux utiliser "dossier" comme nom de variable.
list n'est pas parlant pour désigner une liste de dossier, il vaut mieux utiliser le nom "dossiers" Pour les ensemble d'objets de même nature, il suffit de mettre un s au nom de la variable.

Éviter les abréviations, elle nuisent toujours à la compréhension.

Documentation du code

La documentation du code est nécessaire surtout pour les méthodes qui effectuent des traitements qui ne sont pas descriptible par un simple nom de méthode.

Traitement conditionnel

Pour la clarté, il vaut mieux toujours mettre des crochets sur les block if et for.

Règles générale de programmation

Utilisation de l'abstraction

Contrairement à une idée reçue, il est plus simple de factoriser des classes effectuant des traitements similaires que de dé-factoriser des classes n'effectuant pas le même traitement. Concrètement, l'utilisation de abstraction n'est pas a priori meilleur pour la fiabilité d'un programme.
Les interfaces sont à utiliser dans le cas d'objets devant être manipulés sans qu'on en connaisse la nature précise.
Les classes abstraites, bien qu'elles puissent être utilisée dans un rôle d'interface, ne sont pas recommandable dans cette usage. Il faut les utiliser pour diminuer la taille d'une classe.
- Elle sont suffixées par Base lorsqu'elle représente une base pour les autre classes.
- Elle sont suffixées par Default lorsqu'il s'agit de prototypes, c'est à dire de classe non virtuelles
Quand on a recours massivement à des copier-coller d'une classe sur l'autre alors une classe abstraite peut être utile
Quand on a recours massivement à des copier-coller dans une même classe, alors il est bon de créer une méthode factorisant ces traitements

Debugging distant avec tomcat et eclipse

2008-08-08T05:00:00.000-07:00

Dans setenv.sh rajouter la ligne :

export JAVA_OPTS="-Xmx1024M -Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y"

Si vous souhaitez que le serveur ne démarre que s'il est connecté à éclipse.
Tapez :

export JAVA_OPTS="-Xmx1024M -Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=y"

Ensuite sur eclipse dans le menu debug

Choisissez

- Java Remote Application

Dans project choisissez le projet que vous voulez mettre en relation avec la tomcat, le source doit être celui qui a permis de générer votre application distante, sans quoi vous aurez des résultat incohérent.

Placez les breakpoints où vous le souhaitez, le remote debugging vous permettra de voir les variable, de placer des breakpoint etc. exactement comme dans un debbuging local.

Howto crypt / uncrypt using JAVA and RSA keys

2008-08-05T03:00:00.000-07:00

Problématique :

Dans le cadre d'un bus de données nous souhaitons sécuriser les données en transit. Comme il s'agit d'un bus de transfert asynchrone, lorsque des messages sont stockés sur les files JMS il doivent également être crypté pour n'apparaitre en clair qu'au consommateur. Il n'est pas possible de se servir de SSL puisque le cryptage ne concerne pas que les phase de transport.

Nous allons réaliser le cryptage au niveau des producteurs et consommateurs du bus en nous servant des fonctionnalités venant avec le JDK 5,0.

La principale limitation dans le cryptage JAVA vient de la profusion des différents formats. Pour ce faire nous allons nous servir d'un cryptage à partir de clé publique/clé privée.

La génération des fichiers clé privée et clé publique se fait à l'aide de openssh.

openssl genrsa -aes256 -out /public/cleprivee.pem 2048
openssl rsa -in /public/private.pem -pubout -outform DER -out clepublique.der
openssl pkcs8 -topk8 -inform PEM -in /public/cleprivee.pem -outform DER -nocrypt -out /public/cleprivee.pk8

Le format PK8 est le seul disponible nativement en JAVA, il sert pour la lecture des clés privées

Le format DER est supporté pour les clé publique en JAVA, il sert pour la lecture des clés publique.

Le code suivant crypte et décrypte un message « Mon Cul C'est du poulet » à partir d'une clé publique et privée lue sur dans des fichiers :

// Lecture du fichier de clé publique
File keyFile = new File("clepublique.der");
byte[] encodedKey = new byte[(int) keyFile.length()];
new FileInputStream(keyFile).read(encodedKey);
X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedKey);
KeyFactory kf = KeyFactory.getInstance("RSA");
PublicKey pk = kf.generatePublic(publicKeySpec);

// Encryptage à l'aide de la clé publique
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.ENCRYPT_MODE, pk);
byte[] cypherText = cipher.doFinal("Mon Cul C'est du poulet"
                .getBytes("UTF8"));

// Affichage du résultat du cryptage
System.out.println("----- Bytes cryptés --------");
System.out.write(cypherText);
System.out.println();
System.out.println("----------------------------");

// Lecture de la clé privée
keyFile = new File("cleprivee.pk8");
encodedKey = new byte[(int) keyFile.length()];
new FileInputStream(keyFile).read(encodedKey);
PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(encodedKey);
PrivateKey privateKey = (RSAPrivateKey) kf
            .generatePrivate(privateKeySpec);
cipher.init(Cipher.DECRYPT_MODE, privateKey);

// Affichage du résultat décrypté
System.out.println("----- Bytes décryptés ------");
byte[] clearText = cipher.doFinal(cypherText);
System.out.write(clearText);
System.out.println();
System.out.println("----------------------------");

Ce code ne fonctionne pas quand les données sont trop longue car elle dépasse la taille de la clé. Dans ce cas pour des raison de performances, il vaut mieux utiliser des cryptage symétrique à l'aide de mot de passe. Le code qui suit en donne un illustration.

/** Le chiffreur */
Cipher cipher;

/** La cle de cryptage */
SecretKey secretKey;

public void init(String password) throws Exception {
            cipher = Cipher.getInstance("DES");
            keyFactory = SecretKeyFactory.getInstance("DES");
            DESKeySpec privateKeySpec = new DESKeySpec(password.getBytes());
            secretKey = keyFactory.generateSecret(privateKeySpec);
}

/**
 * Crypte les données 
 * 
 * @return
 * @throws Exception
 */

public byte[] encrypt(byte[] aCrypter) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ByteArrayInputStream bais = new ByteArrayInputStream(aCrypter);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        CipherOutputStream cis = new CipherOutputStream(baos, cipher);
        byte[] buffer = new byte[1024];
        int read;
        while ((read = bais.read(buffer)) != -1) {
            byte[] buffer2 = cipher.update(buffer, 0, read);
            baos.write(buffer2);
        }
        baos.write(cipher.doFinal());
        buffer = baos.toByteArray();
        return buffer;
}
/**
 * Décrypte les données
 *
 */

public byte[] decrypt(byte[] aDecripter) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ByteArrayInputStream bais = new ByteArrayInputStream(aDecripter);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);

        byte[] buffer = new byte[1024];
        int read;
        while ((read = bais.read(buffer)) != -1) {
            byte[] buffer2 = cipher.update(buffer, 0, read);
            baos.write(buffer2);
        }
        baos.write(cipher.doFinal());
        buffer = baos.toByteArray();
        return buffer;
}

Projets EMF

2008-06-30T02:43:00.000-07:00

EMF est un métamodèle qui permet de décrire ses données à travers des éditeur.
Associé à open Architecture, il permettra de faire de la génération de code et sera utile pour générer massivement des services ou des bean (Par exemple si l'on souhaite rendre accessible une référentiel depuis l'extérieur).

Cette solution souffre principalement d'une complexité importante. Une vingtaine de jours environ et nécessaire pour se familiariser avec le produit.
En dépit de cet incontestable défaut EMC c'est une solution de métamodèle qui pourra remplacer avantageusement les outils traditionnel de modélisation dans les entreprise où Eclipse est au centre des développements. Il peu même se substituer à Power AMC ou Pational Rose dans les cas où le développements sont fortement couplés avec la modélisation.

Le premier pas pour se familiariser avec EMF est de suivre le tutorial.

Sécuriser un service Axis2 avec des certificats

2008-06-27T08:17:00.000-07:00

Pour sécuriser un service par une authentification basé sur certificat.

Il faut d'abord créer les magasin de clés pour le serveur et le client. Ces clés serviront pour authentifier les partis.

Ensuite, le serveur fournit un certificat pour le client, il faut considérer ce certificat comme une autorisation de se connecter au serveur (C'est pour cette raison qu'elle doit provenir du serveur). Ensuite, le client l'importe dans son magasin. Ces commandes se passent à laide de keytool.

keytool -genkey -alias serverkey -keystore keystoreserver.jks
keytool -genkey -alias clientkey -keystore keystoreclient.jks
keytool -selfcert -alias serverkey -keystore keystoreserver.jks
keytool -export -alias serverkey -keystore keystoreserver.jks>moncertif
keytool -printcert -file moncertif
keytool -import -keystore keystoreclient.jks  -file moncertif

Il ne reste plus qu'à configurer axis2. Copier d'abord, le magasin de clé (keystore du serveur dans le répertoire classes/ de Axis2). Puis, dans le fichier conf/axis2.xml. Modifier les receiver et sender. Dans notre configuration le truststore est confondu avec le keystore. Si le besoin existait de les séparer le truststore doit contenir le certificat importé et le keystore, la clé de signature du serveur.

  <transportReceiver name="https" class="org.apache.axis2.transport.nhttp.HttpCoreNIOSSLListener">
        <parameter name="port" locked="false">9002</parameter>
        <parameter name="non-blocking" locked="false">true</parameter>
        <parameter name="keystore" locked="false">
            <KeyStore>
                <Location>keystoreserver.jks</Location>
                <Type>JKS</Type>
                <Password>axis2rules</Password>
                <KeyPassword>axis2rules</KeyPassword>
            </KeyStore>
        </parameter>
        <!--parameter name="truststore" locked="false">
            <TrustStore>
                <Location>keystoreserver.jks</Location>
                <Type>JKS</Type>
                <Password>axis2rules</Password>
            </TrustStore>
        </parameter-->
        <!--<parameter name="SSLVerifyClient">require</parameter>
            supports optional|require or defaults to none -->
    </transportReceiver>

    <transportSender name="https" class="org.apache.axis2.transport.nhttp.HttpCoreNIOSSLSender">
        <parameter name="non-blocking" locked="false">true</parameter>
        <parameter name="keystore" locked="false">
            <KeyStore>
                <Location>keystoreserver.jks</Location>
                <Type>JKS</Type>
                <Password>axis2rules</Password>
                <KeyPassword>axis2rules</KeyPassword>
            </KeyStore>
        </parameter>
        <parameter name="truststore" locked="false">
            <TrustStore>
                <Location>keystoreserver.jks</Location>
                <Type>JKS</Type>
                <Password>axis2rules</Password>
            </TrustStore>
        </parameter>
        <!--<parameter name="HostnameVerifier">DefaultAndLocalhost</parameter>
            supports Strict|AllowAll|DefaultAndLocalhost or the default if none specified -->
    </transportSender>

Enfin, il faut en fait rajouter deux lignes dans le code client :

System.setProperty("javax.net.ssl.trustStore", "chemin au clientTruststore");
System.setProperty("javax.net.ssl.trustStorePassword", "mot de passe du clientTruststore");

Pourquoi utiliser Spring dans un Web Service ?

2008-06-27T01:55:00.000-07:00

Spring est un framework d'injection, et pour comprendre son intérêt il faut comprendre ce mécanisme et son intérêt.

L'injection est l'affectation d'une propriété par une sorte de container light(C'est le rôle de Spring). Dans le cadre d'une application simple (C'est à dire standalone) l'injection s'identifie simplement à une forme d'utilisation de pattern singleton.

On se sert de l'injection pour principalement deux cas de figure :

- Configurer et dimensionner par un bean de Configuration.
- Contrôler strictement ses instanciations pour pouvoir dimensionner précisément (Utiliser une seule instance DAO pour l'ensemble de ses instance de service par exemple).

Dans le cadre général des serveurs d'application, la notion d'injection est plus complexe. Il faut avant tout de comprendre qu'elle est liée au classloader et qu'il se pose des problème de scope. Ainsi, ce n'est pas parce qu'on injecte une propriété dans l'application, que cette propriété est injectée dans l'ensemble des instances de services.

Dans le cas des Web-Service, l'utilisation de Spring n'est donc pas triviale. Pour faire court, sil vous utiliser Axis et que vous souhaiter utiliser Spring dans axis, c'est un peu comme de vouloir utiliser deux moteur de Web-Service en un.

Même si cela reste possible, dans la majeur partie des cas il vaut mieux : soit se servir de httpinvoker (inclus dans spring).
Ou bien, si la fonction de container de Web-Service est fondamentale, ne se servir que du conteneur et ne pas utiliser Spring, cela est vrai pour : Axis, Axis2 etc.

Aqcuitement JMS

2008-06-27T01:45:00.000-07:00

Comment fonctionne l'acquittement d'un message jms

La méthode acknowledge permet d'acquitter un message JMS. Dans le mode CLIENT_ACKNOWLEDGE, c'est le client qui décide de l'acquittement.

Lorsque le message est lu il disparait de la file dès le début de la lecture. Mais s'il n'est pas acquitté par le consumer, il reviendra dans la file une fois la lecture terminée.

Démarrer JBoss pour être accessible partout

2008-06-24T07:46:00.000-07:00

Dans le fichier run.bat ajouter -b0.0.0.0 le Serveur JBoss devient accessible sur tout le réseau.

Problème de mémoire avec maven

2008-06-24T05:56:00.000-07:00

%MAVEN_JAVA_EXE% %MAVEN_OPTS%  -Xmx1024m -classpath
 %CLASSWORLDS_JAR% "-Dclassworlds.conf=%M2_HOME%\bin\m2.conf" 
"-Dmaven.home=%M2_HOME%" org.codehaus.classworlds.Launcher 
%MAVEN_CMD_LINE_ARGS%

The system is out of resources.
Consult the following stack trace for details.
java.lang.OutOfMemoryError: Java heap space
        at com.sun.tools.javac.code.Scope$ImportScope.makeEntry(Scope.java:385)
        at com.sun.tools.javac.code.Scope.enter(Scope.java:196)
        at com.sun.tools.javac.code.Scope.enter(Scope.java:183)
        at com.sun.tools.javac.comp.MemberEnter.importAll(MemberEnter.java:132)
        at com.sun.tools.javac.comp.MemberEnter.visitTopLevel(MemberEnter.java:509)
        at com.sun.tools.javac.tree.JCTree$JCCompilationUnit.accept(JCTree.java:446)
        at com.sun.tools.javac.comp.MemberEnter.memberEnter(MemberEnter.java:387)
        at com.sun.tools.javac.comp.MemberEnter.complete(MemberEnter.java:819)
        at com.sun.tools.javac.code.Symbol.complete(Symbol.java:386)
        at com.sun.tools.javac.code.Symbol$ClassSymbol.complete(Symbol.java:758)
        at com.sun.tools.javac.comp.Enter.complete(Enter.java:451)
        at com.sun.tools.javac.comp.Enter.main(Enter.java:429)
        at com.sun.tools.javac.main.JavaCompiler.enterTrees(JavaCompiler.java:819)
        at com.sun.tools.javac.main.JavaCompiler.compile(JavaCompiler.java:727)
        at com.sun.tools.javac.main.Main.compile(Main.java:353)
        at com.sun.tools.javac.main.Main.compile(Main.java:279)
        at com.sun.tools.javac.main.Main.compile(Main.java:270)
        at com.sun.tools.javac.Main.compile(Main.java:87)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at org.codehaus.plexus.compiler.javac.JavacCompiler.compileInProcess(JavacCompiler.java:420)
        at org.codehaus.plexus.compiler.javac.JavacCompiler.compile(JavacCompiler.java:141)
        at org.apache.maven.plugin.AbstractCompilerMojo.execute(AbstractCompilerMojo.java:493)
        at org.apache.maven.plugin.CompilerMojo.execute(CompilerMojo.java:114)
        at org.apache.maven.plugin.DefaultPluginManager.executeMojo(DefaultPluginManager.java:447)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoals(DefaultLifecycleExecutor.java:539)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoalWithLifecycle(DefaultLifecycleExecutor.java:480)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoal(DefaultLifecycleExecutor.java:459)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoalAndHandleFailures(DefaultLifecycleExecutor.java:311)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeTaskSegments(DefaultLifecycleExecutor.java:278)

Les tests unitaires lancés avec maven provoquent des erreurs de mémoire, il est possible de changer le fork afin d'instancier une JVM par test. Par défaut le fork utilisé est once (un seul fork)

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <configuration>
          <forkMode>pertest</forkMode>
          <argLine>-enableassertions</argLine>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

Débuter avec axis2

2008-06-17T08:34:00.000-07:00

Installer Axis2 sous Linux

Télécharger Axis2
Extraire le jar dans /usr/axis2-1.4
Effectuer des liens ln -s /usr/axis2-1.4/bin/wsdl2java.sh /usr/bin/wsdl2java.sh
Effectuer des liens ln -s /usr/axis2-1.4/bin/axis2.sh /usr/bin/axis2.sh
Modifier la première ligne dir=/usr/axis2-1.4/bin/ avec le chemin d'installation réel dans /usr/axis2-1.4/bin/axis2.sh et /usr/axis2-1.4/bin/wsdl2java.sh
Télécharger ANT
Extraire le jar dans /usr/apache-ant-xxx
Effectuer des liens ln -s /usr/apache-ant-xxx/bin/ant /usr/bin/
Exporter la variable export AXIS2_HOME=/usr/axis2-1.4

Supprimer le SOAP12 sur axis2
Modifier le fichier axis2.xml

   <parameter name="disableSOAP12" locked="true">true</parameter>

Utiliser avec Hibernate 3.6.2

Il faut utiliser antlr-1.7.7 et faire ettention au classpath d'une manière générale.
(Le classloader de l'application axis ne permet pas de redescendre plus bas au scope service s'il utilise le scope application.)
Concrètement cela signifie qu'il est impossible de mettre le fichier hibernate dans les librairies de AXIS.
Effectuer une première génération

Créer un répertoire pour votre projet
wsdl2java.sh -uri http://urlduwebservice.com/monservice
Taper ant

Structure d'une archive AXIS2
On peut déployer un service axis sous forme d'un fichier aar.


META-INF/services.xml
lib/*.jar

Il est également possible de le déployer sous forme d'un répertore ayant la même structure.

Note pour se servir du mapping adb à partir de POJO.

Si le bean retourné contient une liste d'élément, il n'est pas possible de se servir des typecast de liste, il faut se servir de tableau.

Génerer un Web Service à partir d'un WSDL et de Maven

Ajouter le bloc

<build>
  <plugins>
   <plugin>
    <groupId>org.apache.axis2.maven2</groupId>
    <artifactId>axis2-wsdl2code-maven-plugin</artifactId>
    <executions>
     <execution>
      <goals>
       <goal>wsdl2code</goal>
      </goals>
      <configuration>
       <package>com.foo.myservice</package>
      </configuration>
     </execution>
    </executions>
   </plugin>
  </plugins>
 </build>


mvn -U axis2-wsdl2code:wsdl2code -DwsdlFile=http://10.202.48.12:8080/axis2/services/OrganisationControleService?wsdl -Daxis2.wsdl2code.package=joe.bigood

Il faut rajouter manuellement et en local la dépendance au plugin.

<dependency>
<groupId>wsdl4j</groupId>
<artifactId>wsdl4j</artifactId>
<version>1.6.2</version>
</dependency>

Utiliser xpath

2008-06-15T02:40:00.000-07:00

Dans cet article, je présente une petite collection de requête exemple de xpath. En la matière, l'empirisme est roi !

Comment retrouver tous les élément img dans un document html (Quelque soit leur hiérarchie)


XPath xpath = XPathFactory.newInstance().newXPath();
InputSource is = new InputSource(new FileInputStream(
      "src/test/resources/testXpath.xml"));
NodeList str =(NodeList) xpath.evaluate("//img",
 is,XPathConstants.NODESET);
log.debug(str.getLength());

Comment effectuer une transformation à l'aide de XPATH (Sans utiliser XQuery)

XPath xpath = XPathFactory.newInstance().newXPath();
DocumentBuilder db = DocumentBuilderFactory.newInstance()
    .newDocumentBuilder();
Document document = db.parse(new File(
    "src/test/resources/testXpath.xml"));
InputSource is = new InputSource(new FileInputStream(
    "src/test/resources/testXpath.xml"));
NodeList str = (NodeList) xpath.evaluate("//img", document,
XPathConstants.NODESET);
Element el = (Element) str.item(0);
el.setAttribute("src", "newValue");
Transformer transformer = TransformerFactory.newInstance()
    .newTransformer();
Source source = new DOMSource(document);
StreamResult sr = new StreamResult(System.out);
 transformer.transform(source, sr);

Attention à la manipulation des namespaces dans XPATH !

Quand les requêtes xpath utilisent des namespaces, deux options sont possible :

La première est d'utiliser les noms absolus et non pas les alias pour effectuer la recherche :


//urn:oasis:names:tc:opendocument:xmlns:text:1.0:span

Malheureusement, cette méthode ne fonctionne lorsque les namespaces comportent le caractère '/' (qui sont descaractère utilisé pour écrire les requête Xpath). Dans ce cas, une deuxième méthode consiste à fournir à Xpath les alias des namspaces que nous utiliserons dans la requête. Cette approche est préférable, car les namespaces qui ne comportent pas de '/' sont plutôt rares.


NamespaceContext ctx = new NamespaceContext() {
public String getNamespaceURI(String prefix) {
String uri;
if (prefix.equals("w")) {
uri = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
}
else if (prefix.equals("ns2")) {
uri = "http://www.davber.com/sales-format";
}
else {
uri = null;
}
return uri;
}
public String getPrefix(String namespaceURI) {
return null;
}
public Iterator getPrefixes(String namespaceURI) {
return null;
}
};
xpath.setNamespaceContext(ctx);

Il faut également rappeler que les namespaces sont héritables par les balise fille lorsque le namespace est déclaré par un attribut xmlns. Concrétement, dans l'exemple suivant, la balise Relationship est à rechercher dans le namespace : http://schemas.openxmlformats.org/package/2006/relationships car la balise parente Relationships est affectée à ce namespace par l'attribut xmlns.


<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId8" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer" Target="footer1.xml"/><Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings" Target="settings.xml"/><Relationship Id="rId7" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/header" Target="header1.xml"/><Relationship Id="rId2"

Dans le cas ou le JDK a une version inférieure à la 1.5, JDOM fournira l'api XPath.



SAXBuilder sxb = new SAXBuilder();
File file = new File(filename);
FileInputStream fis = new FileInputStream(file);
InputSource is = new InputSource(fis);
is.setEncoding("ISO-8859-1");
org.jdom.Document document = sxb.build(is);
// On initialise un nouvel élément racine avec l'élément racine du
// document.
Element racine = document.getRootElement();
XPath xpath = XPath.newInstance("count(/document/firstBranch/order/orderStatus/OrderStatusCode[text()='MARECHERCHE'])");
String result = xpath.valueOf(racine);

Exemple de requête

Pour compter le nombre de balise ayant l'arborescence /document/firstBranch/order/orderStatus/OrderStatusCode et contenant le texte 'MARECHERCHE'


/document/firstBranch/order/orderStatus/OrderStatusCode[text()='MARECHERCHE'])

Pour récuppérer toutes les balises img sous forme de nodeset


xpath.evaluate("//img", document,
XPathConstants.NODESET);

Cloner des beans JAVA

2008-04-09T02:15:00.000-07:00

La methode BeanUtils.cloneBean(Object obj1,Object obj2) permet de répliquer des beans en faisant une introspection sur les méthodes get et set du bean, ceci peut se faire sans utiliser l'interface clonable.

La librairie permettant de faire ceci se télécharge sur http://commons.apache.org/beanutils

    <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutilsartifactId>
            <version>1.8</version>
        </dependency>

Problème de synchronisation avec hibernate

2008-04-08T02:17:00.000-07:00

Lors de l'appel de saveOrUpdate() or update() j'ai une NonUniqueObjectException.

La session utilise un cache entre la persistance et l'objet instance, ce cache est unique (Il se manifeste par les proxy cglig). L'appel de saveOrUpdate determine premièrement si cet objet existe en base, si oui, il construit son proxy CGLIB, ainsi hibernate sait si cet objet existe ou non en base de données. La comparaison de l'objet proxié et de l'objet que nous tentons d'insérer (Non proxié) provoque une incohérence et retourne l'erreur ci dessus.

L'utilisation de la fonction saveOrUpdate() ne sert pas comme on le croit d'abord, à permettre de procéder à des insert ou des update en aveugle.

La solution de ce problème est soit de connaitre l'état de l'objet avant de faire l'insertion en base. (Ce qui diminue notablement le charme de la fonction saveOrUpdate) soit d'utiliser la fonction merge, qui permet de cloné un objet sur son proxy.

marge prend en argument un objet non proxié et retourne un objet proxié clone exact de l'objet passé en argument.

Créer dynamiquement des QUEUE

2008-04-02T02:54:00.000-07:00

Dans le cadre de la création d'un bus de routage je souhaitais pouvoir créer dynamiquement des queues à l'aide de la méthode createQueue(String queuename).

if (queue == null) {
log.info("Création de la queue " +
queueName); queue = session.createQueue(queueName);
}

Cela n'a pas fonctionné car JORAM n'implémente pas cette fonction. Après quelques recherche sur internet, cette fonction devrait être utilisée de manière marginale et pas dans le cadre d'un bus et n'est pas recommandable

12:35:29,484 ERROR BusServiceMdb:96 - Le transfert du message a échoué !
javax.jms.InvalidDestinationException: Proxy could not forward the request to incorrectly identified destination: java.lang.IllegalArgumentException: QUEUELOUCHE: bad id

Modifier le niveau de securité sur Mandriva

2008-04-01T02:53:00.000-07:00

Ayant installé Mandriva 2008, je me suis retrouvé avec un niveau de sécurité trop élevé pour mes besoins (4).

Concrétement, les répertoire home changeais constamment de droits de sorte qu'il n'était pas possible à plusieurs utilisateur de se lire les fichiers

Pour y remédier le commande :

msec -o log=stderr 2

effectue le changement de niveau.

Ces informations sont stockée dans le fichier /etc/sysconfig/msec

UMASK_ROOT=022 (Donne les droit d'accès du repertoire root)
SECURE_LEVEL=3 (Donne le niveau de sécurité)
UMASK_USER=022 (Donne les droit d'accès des répertoire utilisateur)
TMOUT=0

msec est lancé quotidiennement, on le trouve dans /etc/cron.daily

http://club.mandriva.com/xwiki/bin/view/KB/SecureSmsec2?language=fr#HQuelniveaudesC3A9curitC3A9choisir3F

Installer posfix Mandriva avec un relay smtp authentifié

2008-03-13T07:45:00.000-07:00

Dans la fichier /etc/postfix/main.cf

Ajouter les lignes :

smtpd_sasl_path = /etc/postfix/sasl:/usr/lib/sasl2
smtp_use_tls = yes
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
relayhost = smtp.my.network
smtp_sasl_security_options =


Créer le fichier /etc/postfix/sasl_passwd et ajouter les lignes 

smtp.my.network monuser:monpassword

Redémarrer postfix

Utiliser la JConsole avec tomcat

2008-02-28T05:09:00.000-08:00

JConsole est un utilitaire fourni avec le JDK. Il permet de voir l'état d'une machine virtuelle et il est particulièrement utile lorsqu'il s'agit d'effectuer le diagnostic de performance d'une application.

Pour une application Web, il faut observer le tomcat. Pour ce faire, on crée dans le répertoire bin un fichier setenv.sh en ajoutant la ligne suivante :

if [ "$1" = "start" ]; then
export JAVA_OPTS="-Dcom.sun.management.jmxremote \
 -Dcom.sun.management.jmxremote.port=50001 \ 
 -Dcom.sun.management.jmxremote.ssl=false \
 -Dcom.sun.management.jmxremote.authenticate=false"
fi

Ou bien sous windows dans setclasspath (de Tomcat 6.0)
set JAVA_OPTS="-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=50001 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"

Ensuite il faut lancer JConsole et se connecter sur la machine à observer sur le port 50000. Bien entendu, il est possible de sécuriser l'accès à ces informations.

-verbose:class permet d'afficher d'ou sont chargée les différentes classes.

Journalisation distante avec log4j

2008-02-28T01:54:00.001-08:00

La journalisation distante est particulièrement utile pour voir les log dans les environnement de recette et/ou de production.
Sur log4j on ajoute un traceur remote.


log4j.rootLogger=INFO, stdout, REMOTE

log4j.appender.REMOTE=org.apache.log4j.net.SocketAppender
log4j.appender.REMOTE.RemoteHost=mydisplayloghost
log4j.appender.REMOTE.Port=4560

Chainsaw est le client. Il faut créer un SocketReceiver.

Téléchargable à cette URL : http://logging.apache.org/chainsaw/download.html

Utilisation de cargo

2008-02-26T02:33:00.000-08:00

Configuration du plugin en mode local et remote
Voici la ligne à insérer dans le pom.xml

<plugin>
<groupId>org.codehaus.cargo</groupId>
<artifactId>cargo-maven2-plugin</artifactId>
<configuration>
<configuration> (Indique ou sont déployés les war)
<type>existing</type> (Le type par defaut est standalone, c'est à dire que les repertoire de deploiement est créé s'il n'existe pas)
<home>/opt/tomcat/</home> (Nécessaire dans le cas d'un existing)
</configuration>
<container>
<containerId>tomcat5x</containerId>
<home>/opt/tomcat/</home> (Home indique ou trouver le container (le moteur))
</container>
</configuration>
</plugin>

Pour pouvoir déployer sous un chemin spécifique, indépendamment des version, il faut créer le fichier META-INF/context.xml et affecter le nom d'application que l'on souhaite.

<Context path="/gestion" />

Utiliser JMeter à travers un proxy

2008-02-19T08:07:00.000-08:00

Dans le fichier jmeter.bat ajouter à la ligne de commande les paramètre -H et -P pour l'hôte et le port de proxy.

%JM_START% %JM_LAUNCH% %JVM_ARGS% %ARGS%
 -jar "%JMETER_BIN%ApacheJMeter.jar" 
 %JMETER_CMD_LINE_ARGS% -H hostname -P 80

Tester un Web Service à l'aide de JMeter

2008-02-19T07:49:00.000-08:00

Pour tester un Web service à l'aide de JMeter. Il est possible de se servir soit d'un appel SOAP (C'est à dire que la couche d'abstraction Web Service n'est pas utilisée) soit d'utiliser les service en version Beta de test d'un Service Web

Ce post décrit la méthode utilisant un type SOAP

Dans le scénario ajouter un échantillon de Requete SOAP/XML-RPC pour ne pas

Le corps du message est le suivant, il peut être récupéré en mode debug dans une IDE. Il s'agit du SOAPEnvelope du requestMessage du Message envoyé dans le call. Mis le plus simple consite à utiliser le moniteur de AXIS pour voir la requête qui est envoyée.

java -cp axis.jar org.apache.axis.utils.tcpmon

Le SOAP Enveloppe ressemble à ceci.

<soapenv:Envelope
xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>
<soapenv:Body>
<ns1:RechercherListeDossiers 
soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:ns1="http://www.agriculture.gouv.fr/AIDA/2007">
<identifiant xsi:type="xsd:string">
${pacage}</identifiant>

<typeIdentifiant xsi:type="xsd:string">
PACAGE
</typeIdentifiant>

<annee xsi:type="xsd:string">
0</annee>
</ns1:RechercherListeDossiers>
</soapenv:Body>
</soapenv:Envelope>

Deployer avec les sources à l'aide de maven

2008-02-01T06:42:00.000-08:00

Cette commande effectue le javadoc et la mise à disposition des sources.
mvn -DperformRelease=true deploy

JMeter et JFaces

2008-01-31T01:40:00.000-08:00

Afin de tester une application, je suis en train de préparer un test de performances à l'aide de l'outils JMETER.

JMETER à l'aide de son proxy enregistre toutes les requêtes avec paramètres d'entête et de corps. Parmi eux, le paramètre com.sun.faces.VIEW comporte l'état de la vue encodé d'une manière complexe. La valeur de ce champs dépend de l'état des composants et de la structure de l'arbre de composants qui représente la page courante.

L'implémentation de JSF sauvegarde l'arbre de composant et les états associés à chaque composant dans un flux de byte qui est ensuite encodé en base64.(C'est une sérialisation.)
La méthode

com.sun.faces.renderkit.ResponseStateManagerImpl.writeState :


 public void writeState(FacesContext context, SerializedView
view)
        throws IOException {
        ByteArrayOutputStream bos = null;
        String hiddenField = null;

        bos = new ByteArrayOutputStream();
        ObjectOutput output = new ObjectOutputStream(bos);
        output.writeObject(view.getStructure());
        output.writeObject(view.getState());

        hiddenField = " <input type=\"hidden\" name=\""
            + RIConstants.FACES_VIEW + "\"" + " value=\"" +
            (new String(Base64.encode(bos.toByteArray()),
"ISO-8859-1")) +
            "\" />\n ";
        context.getResponseWriter().write(hiddenField);
    }

Lorsque l'utilisateur soumet la page ce champs est décodé par la méthode getTreeStructureToRestore de la même classe.

public Object getTreeStructureToRestore(FacesContext
context,
                                            String treeId) {

        Object structure = null;
        Object state = null;

        Map requestParamMap = context.getExternalContext()
            .getRequestParameterMap();

        String viewString = (String) requestParamMap.get(
            RIConstants.FACES_VIEW);
        if (viewString == null) {
            return null;
        }
        byte[] bytes = Base64.decode(viewString.getBytes());

        try {
            ObjectInputStream ois = new ObjectInputStream(
                new ByteArrayInputStream(bytes));
            structure = ois.readObject();
            state = ois.readObject();
            Map requestMap =
context.getExternalContext().getRequestMap();
            // store the state object temporarily in request
scope until it is
            // processed by getComponentStateToRestore which
resets it.
            requestMap.put(FACES_VIEW_STATE, state);
            ois.close();
        } catch (java.io.OptionalDataException ode) {
            log.error(ode.getMessage(), ode);
        } catch (java.lang.ClassNotFoundException cnfe) {
            log.error(cnfe.getMessage(), cnfe);
        } catch (java.io.IOException iox) {
            log.error(iox.getMessage(), iox);
        }
        return structure;
    }

Si cette valeur est incorrecte, cela ne peut pas fonctionner il n'est pas possible de reconstituer l'objet qui a été sérialisé. C'est comme d'ouvrir un fichier exe avec un
éditeur hexadécimal et de supprimer ou d'ajouter des bytes par ci par là, et d'espèrer que le programme va s'éxécuter correctement. En général, si ce champs est incorrect JSF plante.

Générer un projet web service

2008-01-17T04:17:00.000-08:00

Sous eclipse pour axis 1

New -> Dynamic Web Project pour créer le projet web
New -> Web Service

A partir d'un WSDL, on génère un top-down Web service.
A partir d'une classe java on fait une génération down-top

Choisir cette option dans la combo box.
Choisir l'url du WSDL (WS definition)
Choisir le WS server
Choisir le projet web
Générer le WS dans notre nouveau projet.
Déployer sur le serveur d'application

Pour vérifier son installation, taper http://localhost:8080/nom_application/services/
Le service doit apparaitre

And now... Some Services

AdminService (wsdl)

AdminService

Version (wsdl)

getVersion

MonService (wsdl)

MonOperation

Il reste à implementer la classe suffixée par Impl

Sous eclipse pour axis2

Télécharger Eclipse Eurapa pour J2EE
Télécharger la runtime (ws.apache.org/axis2/) en version WAR et en version BIN.
Dézipper le BIN et référencer le dossier extrait dans Eclipse -> Window -> Preferences -> Web services -> Axis Preferences
Reprendre les étapes précédente en choisissant cette fois la runtime axis 2
New -> Dynamic Web Project pour créer le projet web
New -> Web Service

A partir d'un WSDL, on génère un top-down Web service.
A partir d'une classe java on fait une génération down-top

Choisir cette option dans la combo box.
Choisir l'url du WSDL (WS definition)
Choisir le WS server
Choisir le projet web
Générer le WS dans notre nouveau projet.
Déployer sur le serveur d'application

Pour vérifier son installation, taper http://localhost:8080/nom_application/services/
Le service doit apparaitre

And now... Some Services

AdminService (wsdl)

AdminService

Version (wsdl)

getVersion

MonService (wsdl)

MonOperation

Il reste à implementer la classe suffixée par Impl

Subversion proxy

2008-01-17T01:45:00.000-08:00

Si jamais vous êtes dans un réseau d'entreprise, derrière un proxy, et que vous souhaitez accéder à un serveur SVN distant, vous risquez d'être confronté à des messages d'erreurs impliquant "PROPFIND...".

Voici un petit guide pour résoudre le problème (merci Guillaume), en se basant sur le SVN de Copix pour l'exemple.

Il faut modifier le fichier "servers" de subversion.

sous Linux, c'est : $HOME/.subversion/servers.
sous Windows, c'est : %USERPROFILE%\Application Data\Subversion\servers.

Dans la section [group], ajoutez "copixorg=svn.copix.org", i.e. :

[group]
copixorg=*.copix.org

Puis ajoutez la section suivante :

[copixorg]
http-proxy-host = xxx.xxx.xxx.xxx
http-proxy-port = 8080
http-proxy-username = login
http-proxy-password = mot_de_passe

En utilisant tortoise SVN, il est également possible de le configurer directement dans les setting

Configurer ses datasources tomcat ou jonas et Spring

2008-01-03T05:04:00.000-08:00

Récupérer la datasource dans le code

        Context initialContext = null;
      log.error("Initializing supervision servlet");
      try {
          initialContext = new InitialContext();
          DataSource dataSource = (DataSource) initialContext
                  .lookup("java:comp/env/jdbc/Journal");
          connection = dataSource.getConnection();
      } catch (Exception e) {
          log.error("Cannot get initial context for JNDI: ");
          e.printStackTrace();
          log.error(e);
      }

Une connexion est obtenue à partir du DataSource. Cette connexion est une implémentation particulière puisque son appel à la méthode close() ne la ferme pas réellement mais la rend à nouveau disponible au pool de connexion. Sans cette action permet la connexion ne se libère pas. Pour cette raison, il est très important que la méthode close soit appelée et même en cas d'exception. Sans cela, sans cela le pool de la database perd des connections et il peut résulter une insiponibilité de la database.

Le mieux est de faire close() de la session dans un bloc finally pour garantir son appel.


      try{
            connection=getConnection(); // Permet de récupérer une connexion à partir du DataSource
                 ...
            traitement
                 ...
            resultSet.close();
            connection.close();
            logger.debug(infoDossiers.size() + " dossiers retournés");
            return infoDossiers;
        } catch (SQLException e) {
            try {
                logger
                        .error(
                                "Erreur lors de la requête de récupération des infos du dossier pour l'identifiant : "
                                        + identifiant
                                        + " de type : "
                                        + typeIdentifiant
                                        + " pour l'année :"
                                        + annee, e);
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e1) {
                logger.error("Erreur lors de fermeture de la connection");
            }

Le fichier context.xml définit cette data source. Il peut être placé dans le répertoire META-INF/context.xml, dans ce cas, il est rechargé à chaque déploiement. La ressource peut aussi être définie au niveau du Host en créant un fichier context.xml.default dans le répertoire conf/Catalina/localhost de tomcat. Dans ce cas le déploiement ne reconfigure pas la datasource. Le fichier de context s'écrit :

<Context displayName="Calam-WS"  path="/calam-ws">
 <Resource name="jdbc/MyDataSource" auth="Container" type="javax.sql.DataSource"
               maxActive="100" maxIdle="2" maxWait="5000"
               username="myuser" password="mypass" driverClassName="com.sybase.jdbc3.jdbc.SybDriver"
               url="jdbc:sybase:Tds:ouaga:5000/MyBase</Context>

Au moment de récuppérer l'URL on pourra avoir de problèmes de classpath, dans ce ca le mettre dans les librairies commns de tomcat

Dans le cas d'une utilisation au sein de Spring. Le fichier dao-context.xml a été modifié pour utiliser les datasources

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"
        destroy-method="close">
        <property name="jndiName" value="java:comp/env/jdbc/my-datasource" />
</bean>

Cette datasource se définit dans le fichier context.xml de votre serveur tomcat de eclipse, préciser la datasource.

<Context path="/myapp" docBase="myapp-ihm"
        debug="5" reloadable="true" crossContext="true">
    
  <Resource name="jdbc/my-datasource" auth="Container" type="javax.sql.DataSource"
               maxActive="100" maxIdle="30" maxWait="10000"
               username="user" password="password" driverClassName="com.mysql.jdbc.Driver"
               url="jdbc:mysql://localhost:3306/mydb"/>
</Context>

Ensuite copier la librairie connector-mysql (Z:\00-DOSSIER_PROD\DEquipe\Produits\Poste dev\mysql-connector-java-5.0.5.jar ). Dans votre répertoire lib de tomcat

A l'issue de ces manipulations, un clean et une publication seront prudent.

Installer des datasources sous JONAS

Dans le fichier conf/jonas.properties de votre serveur d'application, ajouter les datasources séparée par des virgules :

jonas.service.dbm.datasources    my_datasource1

Créer le fichier
my_datasource1.properties dans votre répertoire conf et y ajouter les propriétés de votre datasources

#This file is generated by JOnAS
#Fri Feb 26 14:16:50 CET 2010
jdbc.maxconpool=-1
jdbc.connmaxage=1440
jdbc.maxwaittime=10
datasource.url=\ jdbc\:mysql\://my-db\:3306/mydb
datasource.description=no desc
datasource.mapper=rdb
jdbc.minconpool=0
jdbc.connteststmt=SELECT 1
datasource.username=myuser
datasource.name=ftjobs_1
datasource.classname=com.mysql.jdbc.Driver
jdbc.maxwaiters=1000
datasource.password=mypassword
jdbc.connchecklevel=1
jdbc.maxopentime=1440

Créer un fichier jonas-web dans le répertoire WEB-INF de votre application

<jonas-web-app>
<jonas-resource>
<res-ref-name>jdbc/my-datasource</res-ref-name>
<jndi-name>mydatasource_1</jndi-name>
</jonas-resource>
</jonas-web-app>

Hibernate session en multithread

2007-12-11T08:21:00.000-08:00

J'utilise plusieurs threads pour la requête affichage de liste dans une application WEB. Lorsque je lance une requête en servant de la session Hibernate (partagée par les différents threads) j'obtiens le message suivant :
Exception in thread "Thread-41" org.hibernate.HibernateException: Not able to obtain connection
at
org.hibernate.jdbc.ConnectionManager.getConnection(ConnectionManager.java:113)

Le forum http://forums.hibernate.org/viewtopic.php?t=945337 suggère de passer dans un mode transactionnel, mais cela ne fonctionne pas dans mon cas. Il suggère également de laisser spring la possibilité de créer des connexions sur les threads qui en ont le besoin à l'aide de l'option allowCreate

à true ou bien de faire des requête callback.

Réponse :

La session hibernate gèe une seule connection et n'est pas thread safe : on ne peut pas partager une instance de session par plusieurs threads à moins d'utiliser les mécanismes de synchronisation.

C'est la même chose pour une connection JDBC : on ne peut pas avoir un thread qui lit les résultats d'une requête tandis qu'un autre tente de lancer un autre select sur la
même connection.

Tu peux faire rendre ton code thread safe si ton cas d'utilisation le permet en utilisant le mot clef synchronized.

// un seul thread à la fois peut exécuter ce code
synchronized {

// mon code

}

ou

synchronized(maSession) {
// mon code

}

Mysql connection refused Mandriva

2007-12-11T00:12:00.000-08:00

Comment rendre disponible la connexion reseau de mysql sur une mandriva (Connection refused error)
Dans le fichier /etc/sysconfig/mysqld
Commenter MYSQLD_OPTIONS="--skip-networking"

Comment définir le niveau des source JSP

2007-12-10T03:00:00.000-08:00

Dans le fichier conf/web.xml on règle le source level

<pre class="text">   <servlet>
      <servlet-name>jsp</servlet-name>
      <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
      <init-param>
          <param-name>fork</param-name>
          <param-value>false</param-value>
      </init-param>
       <init-param>
               <param-name>compilerSourceVM</param-name>
                  <param-value>1.5</param-value>
                 </init-param>
  <init-param>
      <param-name>compilerTargetVM</param-name>
      <param-value>1.5</param-value>
   </init-param>
   <init-param>
          <param-name>xpoweredBy</param-name>
          <param-value>false</param-value>
      </init-param>
      <load-on-startup>3</load-on-startup>
  </servlet>

http://tomcat.apache.org/tomcat-5.5-doc/jasper-howto.html

Récupérer un objet dans un annuaire JNDI

2007-11-20T05:13:00.000-08:00

Ceci est un fichier contexte exemple qui permet de définir une ressource

<Context displayName="web-service server" docBase="/opt/tomcat/webapps/myservice" path="/myservice" workDir="work/Catalina/localhost/myservice">
<Environment description="" name="pathDepot" type="java.lang.String" value="/var/depot-ws/myservice"/>
<Environment description="" name="facteurAttente" type="java.lang.Integer" value="0"/>
</Context>

Dans le fichier web.xml, il faut utiliser ce code

<env-entry>
    <env-entry-name>docPath</env-entry-name>
    <env-entry-value>c:/doc/doc1</env-entry-value>
    <env-entry-type>java.lang.String</env-entry-type>
</env-entry>

Je propose un bout de code pour récupérer un objet dans un annuaire JNDI.

        Context initialContext = null;
        try {
            initialContext = new InitialContext();
            pathDepot = (String) initialContext
                    .lookup("java:comp/env/pathDepot");
            facteurDattente = (Integer) initialContext
                    .lookup("java:comp/env/facteurAttente");
        } catch (Exception e) {
            log.debug("Cannot get initial context for JNDI: ");
            log.debug(e);
        }

Installer son tomcat

2007-11-20T05:06:00.000-08:00

Installer son tomcat

Maintenant que nous avons vu la théorie, il est temps de commencer la pratique. Avant de commencer il peut être bon de vous avertir que les opérations à venir ne prennent pas une demi heure. Ne vous attendez donc pas à voir fonctionner l'application de démonstration dans le quart d'heure à venir.

Tomcat

Installation

Tomcat est un chef d'oeuvre de simplicité à installer

Pour nos expériences nous allons nous servir de la version 5 du serveur, bien qu'il ne s'agisse pas encore de la version la plus répandue du serveur, elle peut servir dans un contexte de production :

http://jakarta.apache.org/ est l'url de référence pour tous les projets sous licence apache. Bien que cette page puisse sembler relativement austère, beaucoup de composants JAVA de Jakarta ont su s'imposer sur le marché. On y trouve entre autre tomcat et struts :

Tomcat : http://jakarta.apache.org/tomcat

Struts : http://stuts.apache.org/

Cliquez sur le liens download binaries et cherchez tomcat et struts. Comme c'est du code open source, prennez l'habitude, à chaque fois que vous téléchargez un programme pour le developpement d'également télécharger son code source. C'est lavantage de l'open source, un petit coup d'oeil dans le code source vous épargnera peut-être des heures et des heures de tatonnement irrationnels comme cela se produit dans les Apis propriétaires. Vérifiez bien que les versions binaires correspondent au sources.

Note :

Si l'envie folle vous prend de procéder à l'ancienne :"Je compile mon projet". Sachez que les dépendances pour les constructions tomcat sont abracadabrantesques et rappelez vous que le java est portable, c'est donc sans bénéfice pour la performance mais cela vous permettra de debugger et de placer des trace dans le code source. Dézzipper votre tomcat à l'endroit ou vous souhaitez le voir s'exécuter. Par défaut, tomcat n'écrira que dans des sous répertoires de son répertoire racine.

Affectez une variable JAVA_HOME sur le chemin de votre JDK (Pas JRE) en cliquant sur le bouton droit droit sur le poste de travail dans windows.

Placez vous dans le répertoire de tomcat/bin et lancez la commande startup.sh startup.bat suivant que vous vous trouvez sur Linux ou sur Windows. Vous venez d'installer Tomcat. Félicitations !

Maintenant vous pouvez voir le résultat :

http://localhost:8080/

Note :

Il est possible que votre OS fournissent une distribution de Tomcat avec des chemins d'installation diffèrents de ceux par proposé par défault. Je recommande plutôt d'utiliser une arborescence identique à celle qui est proposée dans l'archive de la fondation apache tant qu'il s'agit de développement.

Voici ce que vous devez voir.

Installer les options d'administration

Pour pouvoir contrôler tomcat à distance il est nécessaire d'activer les utilisateurs d'administration. Placez vous dans le répertoire $TOMCAT_HOME/conf

Editez le fichier tomcat-users.xml pour qu'il ressemble à ceci :

Redémarrez tomcat et connectez vous à l'URL. Il vous affiche le manager d'application qui vous permet de lister et de contrôler les différentes applications déployées sur le serveur.

http://localhost:8080/manager/html

Installer Eclipse

Eclipse se télécharge ici : Installez la version 3.0.

http://www.eclipse.org

Comme nous allons nous servir de tomcat, nous allons utiliser le plugin Sysdeo qui permet de contrôller tomcat à travers eclipse. Pour installer le plugin, dezippez simplement l'archive dans l'arborescence de eclipse et relancez eclipse

http://www.sysdeo.com/eclipse/tomcatPlugin.html

Configurez le pluggin dans le menu préférences afin qu'il sache dialoguer avec tomcat.

Nous sommes prêt à travailler sur une application réelle.

L'application de démonstration

L'application de démonstration nous présente une application relativement complexe où vous pourrez retrouver beaucoup des problèmes que l'on peu rencontrer dans le web. Elle présente les notions de :

Connection à une base de données
Login et Enregistrement d'utilisateur
Utilisation du controleur Strut pour le contrôleur
Internationalisation (Charset et détection)
Gestion de formulaire dynamique
Boucle de traitement simple et imbriquée
Sécurisation de la partie administration

Téléchargez l'application de démonstration ici. Elle se présente sous la forme d'une archive WEB (.war) qui est en fait un zip ou les fichiers se trouvent organisé d'une manière spéciale. Pour la déployer il suffit de la copier dans le répertoire webapp de tomcat, l'extraction des fichiers se fait automatiquement.

Maintenant quand vous vous connecter sur l'application manager vous devez appercevoir l'application QuizzTomcat dans la liste.

Cependant, cette application s'appuie sur une base de donnée et il faut l'installer ! Courage c'est presque fini !

Installation de MySQLpour l'application de démonstration

Téléchargez mysql en vesion 4.0 ici

Dans le répertoire c:\mysql\bin lancez winmysqladmin et installez MySQL en temps que service. Lancez en ligne de commande le programme

mysql -uroot

Vous êtes l'utilisateur d'administration. Maintenant nous allons créer la database et donner les droit à l'utilisateur quizz d'accéder à cette database.

mysql>create database quizz;
mysql>grant all privileges on quizz.* to quizz@localhost identified by 'quizz';
mysql>use quizz;

Nous allons créer les tables nécessaires à l'application de démonstration avec le fichier quizz.dmp qui se trouve dans QuizzTomcat/WEB-INF/sql/quizz.dmp à l'intérieur de la WebApp.

Suit une volée d'insultes et peut-être des bip si votre ordinateur est un bavard.

Voila la base de données est initialisée.

Configuration de l'application WEB

Maintenant, prennez le fichier jar qui se trouve dans WEB-INF/lib/mysql-connector-bin.jar et copier le dans le répertoire tomcat/common/lib.

Connectez vous à la console d'administration de tomcat et tapez le user et le mot passe tomcat pour vous connecter.

Placez vous sur Service->Host->Context(QuizzTomcat)->DataSource et selectionnez Create a new DataSource. Et rentrez les paramètres de la data source. Sauvez et commit les changements.

Pour vérifier que tout s'est bien passé, il faut aller voir dans le fichier TOMCAT_HOME/conf/Catalina/localhost/QuizzTomcat.xml qui est le fichier de contexte.

Il doit avoir l'allure suivante :

 <context displayname="Quizz App" docbase="C:\Documents and    Settings\PropriÃ©taire\Bureau\eclipse\workspace\QuizzTomcat" path="/QuizzTomcat" reloadable="true" workdir="C:\Documents    and Settings\PropriÃ©taire\Bureau\eclipse\workspace\QuizzTomcat\work">
 <resource name="jdbc/Quizz" type="javax.sql.DataSource">
 <resourceparams name="jdbc/Quizz">
 <parameter>
 <name>maxWait</name>
 <value>5000</value>
 </parameter>
 <parameter>
 <name>maxActive</name>
 <value>4</value>
 </parameter>
 <parameter>
 <name>password</name>
 <value>quizz</value>
 </parameter>
 <parameter>
 <name>url</name>
 <value>jdbc:mysql://localhost/quizz?autoReconnect=true</value>
 </parameter>
 <parameter>
 <name>driverClassName</name>
 <value>org.gjt.mm.mysql.Driver</value>
 </parameter>
 <parameter>
 <name>maxIdle</name>
 <value>2</value>
 </parameter>
 <parameter>
 <name>username</name>
 <value>quizz</value>
 </parameter>
 </resourceparams>
 <resourcelink global="UserDatabase" name="users" type="org.apache.catalina.UserDatabase">
 </resourcelink></resource></context>

Avant de commencer à rentrer dans le détail du code dans le chapitre suivant, il serait bon que vous parcouriez l'application de démonstration QuizzTomcat

Note :

L'application de démonstration ne resemble pas à ce qu'on pourrait appeler un Tutorial, pour deux raisons

D'abord, en ne restant que sur des applications simples, on se préserve des questions qui font mal quand on passe au réel .
Ce cours est fait pour être détaillé de vive voix.

Configurer une source ftp dans mandriva

2007-11-16T04:55:00.000-08:00

Pour éditer la source de média lancer drakrpm-edit-media et cliquer sur ajouter une nouvelle source personnalisée.

URL : ftp://ftp.national/linux/mandriva/dis/Mandrake/2006/i586/media/main

Chemin relatif vers HDSynthesys : ../media_info/hdlist_main.cz

Déploiement d'un web service

2007-11-05T07:59:00.000-08:00

Objectif du document

Fournir un guide pour le déploiement d’un Web-Service une fois que la fonction est réalisée.

Prérequis
· Eclipse 2.2 ou 2.3 (Version testée)
· Axis 1.3 (Version testée)
Comment déployer sa fonction en tant que Web-Service
Une fois le service développé, nous créons une librairie, mondispositifservice.jar. Il s’agit maintenant de la déployer sous forme de Web-service.

1. Nous créons un projet Web Dynamique à l’aide de eclipse : Fichier --> New …

2. On se laisse guider par l’assistant. Il faut veiller à ne pas selectionner les modules AXIS2 qui sont proposés à la fin de l’assistant (Nous n’utilisons pas AXIS2)

3. Dans le repertoire WebContent/WEB-INF/lib du projet généré, nous copions les librairies

· aida-meta.jar
· aida-commons.jar
· mondispositifservice.jar

4. Le Web-Service est déployé par la commande New--> Web-Service
Un assistant nous est proposé.

Choisir
· L’implémentation du service la classe qui réalise notre fonction dans service implementation

· Le project qui hébergera notre application (le service project )

Dans l’écran suivant vérifier que l’affichage correspond aux méthodes que l’on souhaite rendre accessible par Web Service.

Dans l’écran suivant. Il n’est pas nécessaire d’inscrire son WEB-Service sur un UDDI.

5. Enfin, pour terminer il faut affecter les bons namespaces. Un fichier généré : server-config.wsdd a été généré. Les namespaces doivent être affecté à : http://www.agriculture.gouv.fr/AIDA/2007. http://utils.commons.aida doit être remplacé par http://www.agriculture.gouv.fr/AIDA/2007
6. Au redémarrage du serveur. Le service devrait fonctionner, il faut pour le vérifier verifier que son WSDL utilise le bon namespace (http://www.agriculture.gouv.fr/AIDA/2007) et effectuer un test à l’aide d’un client.
Comment tester son implémentation
Un client correspond à la génération d’un certain nombre de fichier JAVA. Ces fichiers seront par la suite compilés et permettrons de se connecter au web service. Le processus le naturel pour générer un lient Web service est le suivant :

1- Télécharger le descripteur de déploiement
2- Générer le client à l'aide d'un assistant
3- Tester le service
1- Télécharger le descripteur de déploiement
Si le serveur est un serveur axis, http://monserveur.com/axis-webapp/services donne accès à des liens vers les descripteur de déploiement. Sur le lien WSDL télécharger le descripteur de déploiement. (Lien en bleu)

And now... Some Services
· AdminService (wsdl)
o AdminService
· Version (wsdl)
o getVersion
· AidaService (wsdl)
o rechercherListeDossiers
o detailDossier

2- Générer le client de Web service à l'aide d'un assistant
En utilisant Eclipse, la génération d'un client est très simple. Se placer dans un projet java, on générera le client dans un projet, par exemple, ws-test
Dans le menu Fichier --> Nouveau, choisir client de Web Service, l'écran suivant apparait

Dans le second écran on renseigne l'url ou se trouve le WSDL

Les options par défaut, génère seulement le client.
3- Tester le service

Pour se servir du service, on utilise Locator pour résoudre la localisation du service au niveau du réseau, des namespaces, puis on se sert du service comme s'il s'agissait d'une fonction tout à fait ordinaire.

MyServiceLocator locator = new MyServiceLocator();
MyService service = locator.getMyService();
String result = service.fonction01("param1","param2");

Comment décrire une table Sybase

2007-10-26T02:05:00.000-07:00

La commande describe ne fonctionne pas sous Sybase en revanche la commande sp_help nom_de_table (nom_de_view) fonctionne.

L'autre solution est d'utiliser le client de Sybase qui fournit ces informations pratiquement directement.

Mesure des performance d'une application WEB

2007-10-23T06:28:00.000-07:00

Pour un sujet si complexe, il est pratiquement impossible, d'adresser toutes les problématiques dans un seul exposé. Je m'efforcerais de rester aux exigences les plus courantes que tente de vérifier une étude de performance. Nous nous attachons au cas d'une application WEB à visibilité grand public.

Objectifs

Dans la plupart des cas, une étude de performance vise à ce qu'une application réponde rapidement à un utilisateur. Or cette rapidité est un critère psychologique . Un être humain fonde sa détermination de la rapidité : A partir de la complexité qu'il suppose, du prix qu'il accorde à son action, de son âge. C'est à dire qu'une transaction bancaire peut psychologiquement tarder plus que le visionnage d'une publicité.

Toute hypothèse sur l'utilisateur est donc vaseuse, deux utilisateurs ne font pas la même utilisation de performance, c'est pourtant par là qu'il faut commencer. Un utilisateur n'a généralement pas une utilisation prudente d'un logiciel, il vaut mieux donc supposer qu'il clique n'importe comment. Sur une connexion haut-débit, on considère qu'un utilisateur n'attend pas si le temps de réponse est inférieur à deux secondes et l'application doit fonctionner de manière continue.

A partir de là on détermine en gros les critères objectifs :

Rapidité
2 secondes en moyenne pour que service réponde quelques soit l'action

Charge
2000 visiteurs simultanés

Stabilité
Le système doit être stable

Tester les performances

Bien qu'une étude de performance appelle des réponses essentielement techniques, la mesure des performances d'une application ne constitue pas une fin en soi. En effet, la vitesse de traitement et l'occupation mémoire d'une application (la qualité de la programmation) ne suffit pas à mesurer la qualité dans d'une application. L'étude de la performance d'une application doit donc être menée en veillant à ne pas s'éloigner du réel. Tous les aspects techniques sont considérés en gardant à l'esprit ce fil rouge.

Les critères usuels sont :

Stabilité
Rapidité
Capacité de tenir la charge

Rapidité
La rapidité renseigne sur la vtesse d'un traitement. C'est un critère mesurable qui doit être mis en rapport avec la capacité de charge ( elle influencera grandement ce paramètre)

Chaque temps de réponse sera mis en relation avec une charge. L'utilisateur final est l'étalon pour la rapidité.

Charge

C'est la capacité à traiter simultanément un grand nombre de requêtes. On distingue deux seuils :

Le seuil au delà duquel le temps de réponse devient inacceptable
Le seuil d'écroulement

Stabilité

C'est la capacité pour l'application de fonctionner longtemps sans être redémarrée. Le java, avec son garbage collector fournit de fortes garanties de stabilité. Cependant, si l'on se sert de concept un peu avancés comme les Threads, ce genre de problème peut survenir.

On peut qualifier l'instabilité

Par la charge qui provoque l'écroulement
Par le nombre de jours sans redémarrage

Moyens et condition de fonctionnement réel

Un test est d'autant plus pertinent qu'il reproduit les moyens et les conditions réelles de la production.

Serveur production :

Mémoire vive : 2 Go
Vitesse processeurs : 1,5 GHz
Nombre serveurs : 2
Nombre d'applications : 4
Niveau de log INFO
Equilibrage de charge : OUI
On suppose que le débit réseau n'est pas problématique

Moyens et condition de fonctionnement de test de charge

Pour les tests de charge, nous ne disposons pas des outils permettant de reconstituer une expérience utilisateur, nous avons quelques restrictions et nous livrant à certaines approximations :

Nos moyens nous permettent seulement de faire le test dans un contexte n'incluant pas les étapes d'identification. C'est une hypothèse optimiste que de croire que l'identification ne sera pas pénalisante, d'un autre coté, elle ne dépend pas de l'équipe AIDA.

Nous nous baserons sur la requête la plus pénalisante pour le système, nous plaçant dans un cas passimiste. La requête la plus pénalisante est celle qui insterroge tous les partenaires.
La requête sera toujours identique, sur du HTTP, portera toujours sur le même utilisateur et le même dossier.

Objectifs techniques

Estimation

Nombre d'utilisateur potentiel

C'est le nombre total d'utilisateurs capable de se connecter sur le site.

Nombre de visiteurs simultanés

C'est le nombre estimé de visiteurs simultanés sur le site en période chargée

Nombre d'actions moyenne d'un utilisateur

C'est le nombre de requête qu'un utilisateur est succeptible de déclencher pendant sa visite sur le site.

Site à pic de charge

Un site à pic de charge est périodiquement plus chargé (En dehors des cycle naturel jour/nuit et hebdomadaires)

Equlibrage de charge

L'équilibrage de charge intervient au niveau de l'exploitation, aussi il nous avons déjà la garantie d'avoir un système scalable.

Le temps moyen d'une session

C'est le temps moyen d'une session estimé. Mieux veut prévoir court.

Facteur de zapping

Plus il est facile de se déplacer dans l'application et de déclencher des actions, plus les actions seront effectivement déclenchées. Donc un site à clics provoquent un surcroit de requêtes.

Nombre d'utilisateur potentiel : 200000
Nombre de visiteurs simultanés : 2000

Nombre d'actions moyenne d'un utilisateur : 4
Site à pic de charge : Déclenchement ou pas de pic de charge : oui
Le temps moyen d'une session : 5 mn
Facteur de zapping : x 2

A l'aide de ces informations, on pourra se faire une idée du nombre de requêtes effectuées chaque unité de temps, cela demeure cependant indicatif.

2000 x 4 x 2 /5 = 3200 requête/mn

soit 3200 /60 = 53 requête/s

Utilisation de Jmeter

Jmeter permet de lancer des requêtes http en spécifiant des contraintes temporelle (Echelon et cycles)

Scénarios

On définit plusieurs scénarios de charge :

Charge instantanée

On envoie 50 requêtes liste dossier en 1 seconde, chaque requête ne répond que lorsque l'ensemble des dossiers est rappatrié.

La requête envoyée au serveur WS est toujours la même. La réponse l'est également.

Charge durant une minute

On envoie 3000 requêtes en 60 secondes (non effectué)

Résultats

Pour chaque résultat on présente :

Le temps moyen qui est le temps que met en moyenne une requête pour répondre. Il fait la sytnhèse des bonnes et des mauvaise expériences utilisateurs. Plus les résultats ont une forte dispertion et plus il faut traiter cette donnée avec circonspection.
Le temps médian qui est le temps qu'expérimente un utilisateur moyen. Il donne la rapidité d'une requête pour un utilisateur faisant une expérience normale du produit.
La déviation (Ecart-type) donne une représentation de la dispersion des résultats. Elle donne une idée des processus(Thread) zombies.

15 itérations de charge instantanée 50 requêtes

Serveur sur machine bureautique, partenaire réels proxié

Temps moyen : 18 sec
Temps médian : 17 sec
Temps médian : 18 sec

Configuration : Serveur sur machine bureautique, partenaire bouchons proxié sans latence

Temps moyen : 16 secTemps moyen : 16 sec
Temps médian : 3,5 sec
Deviation 18 sec

15 itérations de charge instantanée 100 requêtes

Configuration : Serveur sur machine bureautique, partenaire bouchons proxié sans latence

Temps moyen : 32 sec
Temps median : 3,5sec
Deviation : 87 sec

15 itérations de charge instantanée 150 requêtes

Configuration : Serveur sur machine bureautique, partenaire bouchons proxié sans latence

Temps moyen : 32 sec
Temps median : 3,5sec
Deviation : 87 sec

Conclusion

Dans les situations ou le serveur bouchon est utilisé, ces résultats montrent que la dispersion croit avec la charge, pour autant le temps de réponse médian reste du même ordre de grandeur.

Cette dispersion peut être expliquées par un deadlock dans la partie-core (Qui pourrait être dangereux). Elle peut être également expliquée par une saturation des partenaires, comme nous n'utilisons qu'une simulation de partenaires (Et qu'il est fort probable que les ressources des partenaires ne saturent pas aussi facilement) Il faut donc continuer les test en se servant de partenaires réel plutôt que les bouchons.

Pour ce qui concerne la stabilité : plus le serveur est fragilisé, plus il se fragilise. Il faut donc éviter les zones rouges.

Ces test mettent également en évidence qu'il est nécessaire de mesurer les performances des partenaires depuis le MAP.

Mounting samba file

2007-10-10T08:02:00.000-07:00

I had some trouble performing a samba mount using Mandriva 2006

mount -tsmbfs //10.202.57.110/clunch /mnt/calam/ -ousername=tareum

dmesg displayed the following error :

mount_data version 1919251317 is not supported

I had to use the cifs type for mounting (Probably a more modern standard for the samba filesystem)

mount -tcifs //10.202.57.110/aidacalam /mnt/calam/ -ousername=tareum

You can now have a look in the /etc/mtab file copy/paste the following line in the /etc/fstab line to have the block mounted on startup/

//10.202.57.110/aidacalam /mnt/calam cifs rw,username=tridge,password=foobar 0 0

Bonne pratique pour gérer les environnement multiple dans maven

2007-10-04T10:21:00.000-07:00

A chaque fois qu'un fichier représente un élément de configuration :

- fichier de propriétés
- fichier de configuration des log
- fichier de configuration hibernate
etc.

Il doit être aisément modifiable, c'est à dire qu'il ne doit pas se trouver dans un jar mais se trouvé dans un fichier facilement modifiable. Dans une application Web on placera le fichier de log4j.properties, hibernate.cfg.xml dans le répertoire classes. Ainsi, ces répertoire sont facilement modifiable par un intervenant qui ne connait a priori rien au fonctionnement de l'application.

Quand une application Web utilise un librairie, il ne faut donc pas qu'elle contienne de ressource susceptible d'interférer avec sa propre configuration. Concrètement, il faut éviter de mettre les fichier de configuration dans les partie

src/main des application et les mettre dans le repertoire test.

Il arrive parfois que la configuration soit une tache complexe et qu'il ne s'agisse pas de modifier quelques lignes mais de nombreuse modifications auquels cas il est plus approprié d'effectuer une copie pure et simple des fichiers de configuration et de garder ceux-ci dans le référentiel de sources.

Pour ce genre de problématique, maven a un mécanisme permettant de constituer un package et sa configuration à partir d'un ensemble de fichiers groupé dans un répertoire. Le mécanisme utilisé s'appelle profil. L'utilisation d'un profil conditionne le comportement de maven, il est selectionné par maven en tapant la commande -P

Supposons qu'on ai 4 environnements :

- Développement
- Test
- Recette
- Production

Pour créer un package, on spécifie le profil utilisé. Par exemple mvn -Ptest

Pour gérer ces différents environnements, on créé autant de profils dans le fichier settings.xml qui se trouve dans $HOME/.m2

<settings>
[...]
   <profiles>
      <profile>
          <id>dev</id>
          <properties>
              <mode>dev</mode>
          </properties>
      </profile>
      <profile>
          <id>recette</id>
          <properties>
              <mode>recette</mode>
          </properties>
      </profile>
      <profile>
          <id>test</id>
          <properties>
              <mode>test</mode>
          </properties>
      </profile>
      <profile>
          <id>prod</id>
          <properties>
              <mode>prod</mode>
          </properties>
      </profile>
  </profiles>
  <activeProfiles>
      <activeProfile>dev</activeProfile>
  </activeProfiles>
  [...]
</settings>

Ainsi, chaque fois que l'on tape mvn -Pprod on utilise le profil de production. La configuration des plugin et un ensemble de propriétés d'éxécution sont définies à ce moment. Dans cet exemple on ne configure que les propriétés, ainsi la propriété mode est définie à dev quand on est dans l'environnement de développement.

activeProfile permet de déterminer le profil par défaut (dev)

Pour avoir des ressources différenciées, on peut se servir du filtering maven. Le filtering effectue des substitution lors des copies de ressources. Toutefois, il est plus commode lorsque les modifications sont importantes et portent sur des fichiers en entier d'avoir recours à des répertoires différentiés.
Ainsi on a la structure de répertoire suivante :

- main/resources/resources qui contient les resources communes

et

- main/resources/dev
- main/resources/test
- main/resources/recette
- main/resources/prod

qui contiennent les ressources spécifiques à des environnements.

On modifie le descripteur de projet en modifiantle pom.xml

   <build>
  [...]
  <resources>
  <resource>
  <directory>src/main/resources</directory>
  </resource>
  <resource>
  <directory>src/main/${mode}</directory>
  </resource>
  </resources>
  [...]
<build>

La génération d'un client Web-Service

2007-10-03T22:59:00.000-07:00

La génération d'un client est en réalité la génération d'un certain nombre de fichier JAVA, ces fichiers seront par la suite compilé et permettrons de se connecter de manière simple au web service. Le processus le naturel pour générer un lient Web service est le suivant :

1- Télécharger le descripteur de déploiement
2- Générer le client à l'aide d'un assistant
3- Tester le service

1- Télécharger le descripteur de déploiement

Si le serveur est un serveur axis, http://monserveur.com/axis-webaapp/services donne accès à des liens vers les descripteur de déploiement. Sur le lien WSDL télécharger le descripteur de déploiement.

And now... Some Services

AdminService (wsdl)

AdminService

Version (wsdl)

getVersion

AidaService (wsdl)

rechercherListeDossiers
detailDossier

QosService (wsdl)

echo

2- Générer le client de Web service à l'aide d'un assistant

En utilisant Eclipse, la génération d'un client est très simple.
Se placer dans un projet java, on générera le client dans ce projet, par exemple, ws-test

Dans le menu Fichier --> Nouveau, choisir client de Web Service, on aboutit à l'écran suivant :

Dans le second écran on renseigne l'url ou se trouve le WSDL

Les options par défaut, génère seulement le client.

3- Tester le service

Pour se servir du service, on utilise Locator pour résoudre la localisation du service au niveau du réseau, des namespaces, puis on se sert du service comme s'il s'agissait d'une fonction tout à fait ordinaire.

MyServiceLocator locator = new MyServiceLocator();
MyService service = locator.getMyService();
String result = service.fonction01("param1","param2");

Valider un schéma XSD en java

2007-09-27T05:06:00.000-07:00

La validation d'un schéma XSD permet de vérifier qu'un document est bien conforme. Cette action se fait en même temps que le parsing, pour cela il est nécessaire de mettre dans la première ligne du xml le schéma que doit vérifier les données XML.

<dossier xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation=
"http://mydomain.org/schema/dossier.xsd">

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setIgnoringComments(true);
dbf.setNamespaceAware(true);
dbf.setValidating(true);
dbf.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
try {
  documentBuilder = dbf.newDocumentBuilder();
  documentBuilder.setErrorHandler(new DossierErrorHandler());
} catch (ParserConfigurationException e) {
e.printStackTrace();
}
ByteArrayInputStream bif = new ByteArrayInputStream(xml.getBytes());
documentBuilder.parse(bif);

Il est également possible de forcer le schéma
par


dbf.setAttribute(JAXP_SCHEMA_SOURCE, new File(xsdFile));

Ou bien par une ressource :

InputStream schemaIs = getClass().getResourceAsStream("/schema.xsd");
sp.setProperty(JAXP_SCHEMA_SOURCE, schemaIs);

Utilisation des filters dans maven

2007-09-27T02:15:00.000-07:00

Les filter de maven permettent de copier des resources en modifiant le contenu défini comme étant filtré. Ils sont utiles pour fonctionner dans différent environnement. Notamment dans les fichier de propriétés qui définissent des propriétés pour passer les test unitaires.

Supposons qu'il soit nécessaire de configurer un chemin d'un fichier de log différemment suivant que l'on travaille sur un station LINUX ou sur son poste de développement Windows.

Ce fichier est défini dans un fichier de src/main/resources/log-aida.properties

son contenu est :

aida.logFile=${fileLog}

Il faut définir dans le fichier pom.xml que ces resources sont filtrées

<build>
  <resources>
      <resource>
          <directory>src/main/resources</directory>
          <filtering>true</filtering>
      </resource>
   </resources>
[...]
</build>

Dans le fichier ~/.m2/settings on défini cette propriété

   <profiles>
       <profile>
           <id>unix</id>
           <properties>
               <filelog>/tmp/log.prout</filelog>
           </properties>
       </profile>
   </profiles>
   <activeprofiles>
       <activeprofile>unix</activeprofile>
   </activeprofiles>

Dès lors quand on tape mvn resources:resources le fichier src/main/resources/log-aida.properties est copié vers target/classes/log-aida.properties et son contenu est

aida.logFile=/tmp/log.prout

Les Web Services

2007-09-26T07:47:00.000-07:00

Généralité

Ces dernière années ont vus l'émergence d'un nouveau type d'appel distant s'appuyant sur le protocole HTTP : Les Web Services . Ils permettent de réaliser des appels distants de manière standard et simple.

Bien que, ces aspects sont abordés par CORBA et RMI, la complexité de ces protocoles les a réservés à des applications très techniques. Les Web Services, en revanche sont facile à mettre en oeuvre .

Les services Web permettent de traiter les requêtes synchrones. Fonctionnement, un Web Service est comme un Call mais ses fonctions de sérialisation et de transport sont réalisées à l'aide des protocole HTTP et SOAP et non plus en utilisant une méthode propriétaire. Initié par Microsoft, SOAP (Simple Object Access Protocol) fournissait un cadre pour une généraliser les opérations de Call en utilisant le XML. Le Web Service ajoute les bénéfices du HTTP à SOAP. Le Web Service possède donc les qualités ces protocoles.

La robustesse de HTTP
L’interopérabilité du XML
Les réalisations de Web Service sont indépendantes du système d'exploitation et du langage de programmation utilisé.

A l'aide de son langage de description (WSDL), il permet de faciliter les échanges de données. Il permet également la communication normalisée entre les applications au sein des entreprises et entre les entreprises. Le langage de description de WebService : le WSDL (Web Service Deploiement Langage) permet de décrire un Web Service.

Il convient de bien comprendre les atouts qui ont fait le succès des Services Web et pour savoir les utiliser à bon escient.

Ils s’appuient sur le protocole le plus robuste de tous les réseau : HTTP
Ils ne sont pas propre à un langage en particulier et sont formalisé par un standard
Ils proposent un langage de description de service (Descripteur simples à comprendre)
Ils sont à la mode et dispose donc d'un support important

Prérequis technique

Pour utiliser des services Web, il faut d'abord un serveur d'application et d'un moteur de Web Service. En java, les implémentations incontournables sont

AXIS implémentation libre sous licence apache
Websphere
WebLogic

Le rôle de ce composant est de répondre au requêtes HTTP en les transformant en appel d'un efonction JAVA.

Dans le cadre d’un développement de Service-Web il est recommandé de n’avoir aucune interface visuelle dans la Webapp.

Utilisation des service Web

Le « Service Web » est utilisé pour retourner le résultat d'une fonction de traitement d'un objet Métier. Concrètement, vous n'aurez pas à modifier vos anciens développements pour transformer votre classe métier en service Web car vous utiliserez les Web Services comme une surcouche. Cela permet d’éviter les re-développement de l'application.

Une bonne pratique consiste à ne pas appeler directement les classes métiers mais en passant par des «Classes Façades » qui permettent de définir clairement quelles sont les méthodes de accessibles par le Web.

Avantages

Dans les systèmes d'information, il est fréquent de voir des réseaux se modifier, soit du point de vue des machines soit du point de l'architecture. Le service Web est alors idéal car il ne nécéssite que peut de développement pour être mis en place autour d'une ancienne architecture et garanti un agencement très souple de l'architecture.

Bien souvent, vous mettrez en comparaison les Web Service avec des appels RMI car la fonction première du RMI (Remote Method Invocation) est la même que les services WEB.

RMI	Web Service
Faible interropérabilité	Forte interropérabilité
Cout de traitement 2/3 moins élevé que le Web Service	Cout processeur élevé
Transmet l'état de l'objet	L'état de l'objets doit être transmis en paramètre.
Complexe à mettre en ouvre	Simple à mettre en oeuvre
Protocole nécessitant une forte cohérence des unités de traitement entre elle. (Quand un composant ne fonctionne plus plus rien ne fonctionne)	Protocole robuste.
Difficile à optimiser	Plus simple à optimiser.

Dans les pages précédentes j'ai souvent affirmé que la performance d'une méthode dépendait de l'intelligence de la programmation. Il en va de même pour les services Web, même s'ils sont réellement plus coûteux que des appels RMI, il sont plus simples à étudier et donc à optimiser.

Si vos machines ne se trouvent pas dans un même endroit, il n'est pas nécessaire de se poser de question c'est le Web Service qu'il faudra choisir. Dans le cas contraire, pour contrebalancer le couts des appels au Web Service il faut tout simplement diminuer le nombre des appels et augmenter la granularité.

En un mot, toute la richesse du Web Service réside dans sa simplicité et son interopérabilité. Ces qualités doivent être préservées.

Ce que ne sont pas les Web Services / Inconvénients

Les Web Services ne sont pas une méthodologie de développement de services utilisée dans le Web. En clair, ce n’est pas parce que votre service est utilisé dans une page Web qu’il doit utiliser un Web Service.

En outre, les services Web ne sont pas appropriés pour tous les types de traitements.Ils ne concernent qu’une sous classe de service (Qu’on appelle les services sans état – stateless ) :

Ne les utilisez pas pour des processus asynchrones.
Ne les utilisez pas pour des fonctions qui doivent être fréquemment appelées

Enfin, il faut signaler que les Web Services sont à la mode et plus ou moins succeptible d'être assaisonés à toutes les sauces. A vous de voir...

Le plus simple des services Web

Le plus simple des services web est une simple classe JAVA que l'on utilise avec l'extension JWS (Java Web Service) et qui se place dans un repertoire de la WebApp. On peut alors directement appeler les service en question par un Call. Vous programmer donc une fonction Web de la même manière qu'une JSP. Le fin du fin étant qu'elle peut être compilée à la volée.

Architecture

L'architecture des applications

Par rapport aux applications standard l'architecture d'une service web est un petit peu différente, en effet, il est possible de déployer un service web unitairement. Par conséquent il est envisagable de n'avoir qu'un seul moteur de service Web.

Supposons que vous ayez deux applications Web : une application de facturation et une application pour les payes. Ces WS sont appeléspar une troisième application extérieure. La première tendance sera de rajouter à chaque application un moteur de service web. Cette solution n'est pas mauvaise, toutefois elle presente l'inconvénient de caler le cycle de vie de l'application de Service Web sur le cycle de vie de l'application Web IHM. Généralement les services Web sont appelés à partir de traitements batch. Ceci a pour conséquence de rendre interdépendantes au panne et maintenance l'application WebService de l'application IHM. Il vous faudra donc faire un arbitrage entre le degré d'interconnexion entre le service Web et l'application et la tolérance au pannes que vous souhaitez assurer.

Ces trois possibilités sont détaillées dans le schéma ci dessous.Les grand rectangles représentent les application.

La mécanique interne d’un service Web

Pour utiliser un service Web il faut réaliser les 5 couches techniques que l'on voit sur le dessin ci dessous. Nous n'évoquerons pas la partie Métier du coté du serveur car elle est complètement dépendante de la problématique.

Configurer le dispatcher : C'est ici que nous décrivons notre service Web à partir du langage de description de service web WSDL.
Couche de Médiation : Elle nous permet d'écrire notre requête directement à partir du code JAVA sans avoir une seule ligne de XML à taper. Ces médiateurs sont générés automatiquement à partir du fichier WSDD.Nous le verrons dans le chapitre suivant
Les façades : Il s'agit de l'opération qui consiste à utiliser les classes métier. Dans les facades on doit gérer les instanciations des classes métier.

Préparer votre classe métier

Vous avez le choix dans les réponses que le web service vous retournera après son appel, ce peut être des type simples comme int ou double, mais le plus souvent vous souhaiterez faire transiter des type structurés (des beans). Cependant, les web service ne permettent pas de sérialiser et de désérialiser des types aussi complexes que l'on pourrait le souhaiter. Par exemple les interfaces java.util.Set ne sont pas sérialisables dans les web service et il est nécessaire de passer par une étape intermédiaire.

Lorsque vous créez votre web service à partir d'une classe métier, il vaut mieux faire intervenir une classe façade qui au lieu de retourner des beans complexe qui intègre de la logique métier ne retournera que des beans stricto senso qui seront des copies de vos bean métiers qui leur enlève le superflux.

On a donc trois opérations pour créer notre façade :

Créer des beans de retour allégés
Créer des beans de paramètres allégés
Créer la méthode façade acceptant ces beans

Les utilitaires vont générer un WSDL qui comportera les informations qui permettront d'enrichir le bean des méthodes qui permettront la sérialisation. Il existe deux méthodes pour enrichir le bean, soit on utilise des classes qui manipuleront le bean pour le remplir, c'est cette méthode qui est retenue par IBM, soit le code du bean est modifié, c'est cette philosophie qui est utilisée par Axis.

Création d'un fichier WSDL à partir d'une classe JAVA

Une fois que notre service est isolé à l'aide des façade, il est temps de créer le descripteur de Web Service. A partir de ce descripteur, nous allons enrichir le bean pour le rendre serialisable.

WSAD

Puis, sous WSAD c'est très simple, il suffit de se servir de l'assistant et de se laisser guider.

Dans cet environnement, les classes de médiation sont appelée proxy. Vous devez choisir votre implémentation, selectionner la classe que vous souhaitez transformer en WebService. Attention, dans les premières versions de WSAD, ce n'est pas très fiable.

Axis et Eclipse

Axis nous fournit des utilitaires qui permettent de générer le WSDL.

% java org.apache.axis.wsdl.Java2WSDL -o wp.wsdl -l"http://localhost:8080/axis/services/WidgetPrice"
-n "urn:Example6" -p"samples.userguide.example6" "urn:Example6" samples.userguide.example6.WidgetPrice

où

-o indique le nom du fichier de sortie
-l indique l'endroit ou est rendu le service ( Notez qu'à l'interieur d'un web service nous avons des information qui sont propore au serveur.
-n est l'espace de nommage du WSDL cible
-p indicates a mapping from the package to a namespace. There may be multiple mappings.
the class specified contains the interface of the webservice.

Nous générons un fichier WSDL qui décrit la signature de la méthode ainsi que le serveur qui rend ce service. En parcourant ce fichier on voit qu'il contient les informations

La première partie types contient la description des Types (Bean de paramètre et de résultats qui seront utilisés dans notre WebService.
La deuxième partie comporte la structure des messages.
La troisième partie comporte les bindings.Qui représente les fonctions accessible par notre service.
La quatrième partie nous présente la liste des services chaque service est rattaché à une URL.

Appel de Web Service

Nous avons deux possibilités pour tester un service web que nous avons déployé sur le serveur :

Utiliser le client de test fourni par WSAD et accessible par un click droit sur un WSDL
Générer automatiquement les classes de proxy à partir du WSDL et les utiliser

WSAD propose un assistant pour vous aider à construire des clients de WebService à partir de
Descripteurs de Web Service (Fichier aux extensions .wsdl ). Le WSDL comprend des informations de :

Définition de Schéma de message.
Point d’appel (EndPoint)

Le produit de cette opération est une série de classes qui vous permettrons d’appeler les services Web et de reconstruire un objet à partir d’un flux.

Penser au moment de livrer le wsdl à remplacer l’adresse ‘localhost :9080’ par le nom ou l’adresse IP du serveur sur lequel le service est déployé.

La génération des classes de médiation

Vocabulaire :

Binding désigne en anglais un lien entre deux choses, c'est précisement ce qu'il fait : Il vous permet de relier votre code java au web service en ignorant le fonctionnement d'une web service. C'est souvent bien utile. En pratique on se sert pratiquement toujours des bindings.

Les binding sont générés en même temps que sont généré vos bean enrichis.Alors utilisez les !

Cas d'école :

Etudions le descripteur de déploiement des WebServices fournis par google : GoogleSearch.wsdl. Nous y voyons le schéma du Web Service. A partir de ce schéma, il nous est possible de générer les classes qui permettrons d'appeler ce service sans que jamais nous n'ayons besoin de coder nous même les fonctions d'appel. Il faut comprendre que les bean enrichis doivent être présent non seulement du coté serveur mais également du coté client.

Voici la ligne de commande utilisée pour axis

java org.apache.axis.wsdl.WSDL2Java -o src -d Session -s -S true -Nurn:Matrix matrix.ws wp.wsdl

Déploiement

Il nous reste ensuite à générer les fichiers de déploiement, ces fichiers seront utiles pour informer le dispatcher des services qu'il doit rendre. C'est le seul lien qui exite entre la classe JAVA que vous avez créer et votre dipatcher de requête. Sans le savoir vous les avez déjà générés, ce sont les fichiers deploy.wsdl et undeploy.wsdl qui se trouvent au même endroit que vos dindings.

Table d’association des type JAVA->SOAP

Vous pouvez vous servir de ce tableau pour comprendre ce qui est décrit par votre WSDL.

xsd :base64Binary	byte[]
xsd:boolean	boolean
xsd:byte	byte
xsd:dateTime	java.util.Calendar
xsd:decimal	java.math.BigDecimal
xsd:double	double
xsd:float	float
xsd:hexBinary	byte[]
xsd:int	int
xsd:integer	java.math.BigInteger
xsd:long	long
xsd:QName	javax.xml.namespace.QName
xsd:short	short
xsd:string	java.lang.String

Et l'interropérabilité ?

Dans certaine entreprise des petites applications ont parfois des besoins d'appeler des services qui sont déjà disponibles sur d'autre serveurs. Les WS seront intéressant pour faire communiquer une application PHP et JAVA.

JAVA
C++
Perl / Python etc.
Rebol
PHP

Le langage JAVA

2007-09-25T04:36:00.000-07:00

Les interfaces

Une interface possède en Java

Un nom
Un package
Des méthodes

Exemple de code :


package mypackage;

interface Voiture{
accelere();
freine();
tourneLeVolant(float degres);
};

Les classes

La classe est l'un des élément de base de java. Une classe d'objets ou classe doit avoir :

Un nom
Un package
Des attributs
Des méthodes

Voici une définition de classe :

Exemple de code :

package mypackage;


class Client {
String nom;
String prenom;
};

Les relations entre les classes

On ne peut dériver un classe que d'une seule classe en Java, c'est une des limitation de Java savament désignée par : Il n'est pas possible de faire du polymorphisme en Java. (Ca fait bien ! )

Voici une définition de classe qui dérive de la classe client. La dérivation s'écrit à l'aide du mot clé extends

package mypackage;

class ClientHeureux extends Client{
void smile();
};

Le mot clé extends signifie que la classe ClientHeureux est une spécialisation du Client. Le ClientHeureux possède aussi un nom et un prénom mais il possède la spécificité de sourire.

Les portées ou scopes

Un scope est utilisé pour caractériser le champ d'application d'une fonction. Une bonne pratique consiste à utiliser les visibilité minimale, toutefois, Voici les différentes visibilités qui sont utilisées en JAVA.

default
private
protected
public

Private

Caractérise un attribut ou une méthode organique, c'est à dire qu'elle n'est accessible que depuis la classe d'objet considérée.

Protected

Caractérise un attribut ou une méthode organique. Toutefois, les descendant des cette classe d'objet auront également accès à cette méthode.

Public

Caractérise uns attribut ou une méthode qui est accessible depuis n'importe quelle classe.

Default

Caractérise un attribut ou une méthode accessible depuis tout le package. Si aucun mot clef n'est donné, c'est cette visibilité qui est utilisée.

Les packages

Les packages permettent d'organiser les classes et interfaces en sous ensembles, c'est la notion de package. Dans un package on place plusieurs classes.

Du point de vue strict de la programmation cette organisation apporte des bénéfices au niveau de la clarté.

Ce qui est important c'est de définir pour le projet une organisation homogène. Dans la pratique, on utilise les package pour faire un découpage fonctionnel et ou technique.

Par exemple, toutes les classes qui se rapportent à un client peuvent être regroupées dans un même package, on procède dans ce cas à un découpage fonctionnel. Il est également possible de regrouper les classes d'un point de vue technique, par exemple on regroupe entre elle toutes les classes se rapportant au parsing d'un fichier.

Les Exceptions

Une des caractéristiques de JAVA est de gérer depuis la runtime les exceptions. Ainsi il est impossible de créer un erreur de segmentation. Tous les programmes JAVA se termine donc de manière normale.

Pour parler des exceptions il est nécessaire de se placer dans le cadre de l'execution d'un programme. Un programme est manipulé au niveau de la runtime comme une pile d'appel. Le sommet de la pile donne l'instruction qui va être executée. Parfois certaines opérations sont impossibles et provoquent un résultat indéterminé, c'est par exemple le cas d'une division par zéro. Le processeur n'est pas en mesure de donner le résultat, il a donc le choix :

Soit il donne une réponse aléatoire... Mais ce n'est pas le genre de l'informatique
Soit il s'arrête et déclare qu'il ne sait pas faire
En Java, il a une troisième possibilité : Il lance une exception.

Attention à ne pas confondre une exceptions avec le traitement d'erreur, car il y aura toujours des cas qu'on avait pas prévu, on s'appuie sur la machine virtuelle pour ces cas là. Pour autant, il n'est pas bon de faire du traitement d'erreur avec des exceptions.

La lancée d'une exception c'est comme une bulle dans la stack, elle remonte jusqu'a ce qu'un bloc d'un frame supérieur soit en mesure de traiter l'exception.

La lancée d'une exception se fait par le mot clé throw. Si l'exception n'étend pas une RuntimeException, il est nécessaire que vous ajoutiez dans votre code un block de traitement d'exception par les mots clés try et catch.

La récupération d'une exception se fait par le mot clé catch.

Pour pouvoir attrapper une exception il est nécessaire de l'avoir placée dans un block try.

Il existe deux types d'exceptions :

Les exceptions standards qui dérivent de la classe Exception
Les exceptions RuntimeException qui sont une sous classe de la classe des Exception, celle ci sont déclenchées par une impossibilité du processeur de traiter l'instruction. Par exemple ArithmeticException est une RuntimeException car le processeur ne sait pas diviser par zéro.

Clément Soullard, Juin 2004

Ce document est placé sous la licence libre Free Doc. La reproduction partielle ou totale de ce document est permise et encouragée. Cependant, les images du film Matrix ne sont évidement pas libres de droits.

Si vous faites évoluer le document merci de me tenir au courant.

Barbarismes Javaien et liens

Java Term	Definition	More Information
Applet	An applet is a Java program that runs within the web browser. Applets use a graphical user interface and may have text, images, buttons, scrollbars, and sound. AWT and SWING are frequently associated with articles and tutorials about creating applets.	Building Applets Trail: Writing Applets Package `java.applet`
AWT	The Abstract Window Toolkit (AWT) is a package of classes for creating components such as buttons, menus, and scrollbars for applets and standalone applications.	AWT Fundamentals Using the AWT to Create a GUI Package `java.awt` Description AWT Forums
Java API	The Java Application Programming Interface (API) is prewritten code, organized into packages of similar topics. For instance, the Applet and AWT packages include classes for creating fonts, menus, and buttons. The full Java API is included in the Java 2 Standard Edition download.	API Documentation Building an Application
JavaBeans	JavaBeans architecture provides a way of designing reuseable software components that can be visually manipulated in builder tools. Beans can besimple like buttons, or more complex like a tool to access databases.	JavaBeans Technology JavaB eans Technology: Unlocking The BeanContext API JavaBeans Forums
Java Foundation Classes (JFC)	The Java Foundation Classes (JFC) are a set of GUI components and other services simplifying the development and deployment of desktop and Internet/Intranet applications.	Java Foundation Classes (JFC) JFC FAQ Project Swing Forum Accessibility Forum
Java Native Interface (JNI)	JNI is the native programming interface for Java that is part of the JDK. The JNI allows Java code to operate with applications and libraries written in other languages, such as C, C++, and assembly. Recommended only for advanced programmers.	Trail: Java Native Interface Chapter 5: JNI Technology Java Native Interface, 1.2
JavaServer Pages (JSP)	Create dynamic web pages with JSP by embedding scriptlets (Java programming language code) with HTML. JSP pages process forms, perform calculations, or do anything else that can be written with the Java programming language. To develop and test JSP, download the JavaSever Web Development Kit, and J2SE.	JavaServer Pages Tutorial JavaServ er Pages: A Developer's Perspective JSP Pro (Two chapters in PDF) Core Servlets and JavaServer Pages (Two chapters) JavaServer Pages Forums JavaSever Web Development Kit Forums
Java 2 Platform, Enterprise Edition (J2EE)	The J2EE platform provides a component-based approach to the design, development, assembly, and deployment of enterprise applications. The J2EE platform gives you a multitiered distributed application model, the ability to reuse components, a unified security model, and flexible transaction control.	Java 2 Platform, Enterprise Edition J2EE Tutorial Downloads Java BluePrints Enterprise JavaBeans(EJB) Technology Fundamentals Java Programming Forums
Java 2, Micro Edition (J2ME)	Java 2 Micro Edition (J2ME) is targeted for the consumer and embedded market. The API specifications are based on Java 2 Standard Edition (J2SE), but modified to meet the unique requirements of each product. J2ME makes it possible to write Java applications for cell phones, smart cards, pagers, and other consumer devices.	Java 2 Micro Edition (J2ME) Technology Wireless Developer How Wireless Applications Work Java Wireless Technology Discussions
Java 2, Standard Edition (J2SE)	This download includes the essential compiler, tools, runtimes, and APIs for writing, deploying, and running applets and applications in the Java programming language.	Java 2 Platform, Standard Edition (J2SE) Online Documentation Introducing the Java Platform Getting Started
Java Virtual Machine (JVM)	The Java virtual machine executes instructions that a Java compiler generates. This run time environment, or JVM, is embedded in various products, such as web browsers, servers, and operating systems.	Java Virtual Machine Forums
JDBC	JDBC is a Java API for executing SQL statements. By using the JDBC API, you can access almost any data source, from relational databases to spreadsheets to flat files. J2SE includes the JDBC API.	JDBC API Lesson: Learn JDBC Basics JDBC Forums
JDK	JDK is the short-cut name for the set of Java development tools, consisting of the API classes, a Java compiler, and the Java Virtual Machine interpreter, regardless of which version. The JDK is used to compile Java applications and applets. The most current version is the J2SE., the preferred term these days. If you use J2SE 1.2 and later to develop applications, you are using what's known as the Java 2 Platform.	Download J2SE 1.4 Online Documentation Introducing the Java Platform Getting Started
JINI	The Jini network technology enables any service--from enterprise systems to kitchen appliances--to network smoothly and simply. The Jini architecture lets each service (device or software) tell others how to talk to it, without any administrator settings.	Jini Network Technology Distribu ted Events in Jini Technology How to Attach a User Interface to a Jini Service Core Jini General Distributed Computing Forums
Project Swing	The `javax.swing` package of classes is used to create GUI components for applets and applications. Project Swing classes enable programmers to specify a different look and feel for each platform, or a uniform look across all platforms. Swing is the project code name for the lightweight GUI components in JFC.	Java Foundation Classes Fundamentals of JFC/Swing: Part I Fundamentals of JFC/Swing: Part II Creating GUI with JFC/Swing Project Swing: Building a User Interface Project Swing Forums
RMI	Remote Method Invocation (RMI) lets Java applications communicate across a network. The communicating applications can be running on different computers on opposite sides of the planet. This higher-level and method-based approach to network communications allows access to a remote object as easily as a local object.	Java Rmote Invocation (RMI) Fundamentals of RMI Short Course RMI-IIOP Documentation Lesson 8: Remote Method Invocation RMI-IIOP Forums
Servlets	A servlet is an extension to a server that enhances the server's functionality. Servlets are most commonly used to process forms, handle redirects or authenticate user names and passwords, and create dynamic content.	Java Servlet Technology Lesson: Overview of Servlets Lesson 5: Writing Servlets What 's New in the Servlet API? Funda mentals of Java Servlets JavaServer Web Development Kit Forums

Introduction au JAVA

2007-09-25T02:07:00.000-07:00

Allo. Comment JAVA ?

Principes de base :

Langage et plateforme JAVA

Le JAVA est un langage informatique orienté objet qui a été créé pour satisfaire à plusieurs besoins :

Simplicité de programmation
Portabilité
Simplicité de la gestion de la mémoire

Pour être exact il faut distinguer le langage JAVA de la plateforme de developpement JAVA qui sont souvent assimilés :

Une plateforme de développement permet de créer et d'exécuter des programmes.
Un langage permet de décrire soit des objets, soit des actions.

La plateforme Java est utilisée pour exécuter des programmes, il existe déjà des programmes écrits en JAVA qui tournent sous des plateforme autre que JAVA : la plateforme Mono ou .NET.

Cette plateforme est constituée par :

Un compilateur
Un interpréteur ou runtime
Des librairies ou APIS

Les trois étages de représentation en JAVA

En réalité, la transformation en langage machine repose sur deux moments :

La compilation
L'interprétation runtime

Forces et faiblesses du JAVA

Le JAVA est simple, facile à programmer, facile à debugger

Sans cet élément crucial, il est probable que le JAVA n'aurait pas connu un tel succès

Le kit de développement est gratuit et la communauté de développeurs est énorme

De nombreux frameworks sont proposés gratuitement pour accélérer vos développements.

Le JAVA est réellement portable sur les environnements Solaris, Linux, Windows, Mac OS-X et AIX sur tous les aspects non visuels.

C'est a dire qu'aucun développement n'est nécessaire pour effectuer un portage.

Le JAVA est portable facilement quand il y a des aspects visuels à prendre en compte.

C'est a dire que les bugs rencontrés lors des portages seront mineurs et facilement corrigeables.

Le JAVA a des performances moindres sur les aspects nécessitant beaucoup de traitement processeur ( Vidéo, 3D )

Par contre, il est suffisant pour l'imagerie et la publication.

Le JAVA n'est pas recommandé lorsqu'on souhaite se servir de fonctions propres à un OS

Le principe de JAVA étant de factoriser les talents communs à tous les OS, il faudrait revenir sur sa portabilité si l'on souhaitait exploiter des spécificités du système.

Comparatifs technologiques

J’ai un jugement relativement peu nuancé concernant le bénéfice de la technologie JAVA, si je suis intègre dans mon prosélytisme, il n’en demeure pas moins que mon jugement est sans doute une version légèrement euphorique du marché. Cet avertissement donné, je ne parlerai plus au conditionnel ! Le Java, disais-je, est formidable : Il peut être utilisé dans tous les champs connus d’applications de l’informatique :

Interface Utilisateur (Client Lourd)
Interface Web (Client Léger)
Middleware (Batch et Workflow)
Informatique Scientifique
Informatique embarquée
Temps Réel

La différence est que suivant le domaine il ne possède pas les mêmes qualités à opposer à ses adversaires.

Interface Utilisateur

Pour les interfaces utilisateurs on utilise essentiellement les Langages Objet comme C++ et Objective C pour les applications grand public. Ce type d’application il nécessite des installeurs.

Pour les petite application d'entreprise on utilise également du VB et d’autres langages scriptés, les exigences de robustesse et de facilité d’installation sont habituellement moindres. Par rapports à ces deux alternatives les avantages du JAVA sont les suivants :

Pour les applications grand public, l’installation est simplifiée du fait de la portabilité native du JAVA.
Par rapport aux applications utilisée dans les entreprises basé sur des scripts. Le JAVA possède un design (lié à la force/rigueur du langage) qui lui donne un amortissemenet plus long à ce genre d’application. Cela qui garanti au prix d’un effort un peu plus important au début d’avoir une meilleure pérennité du produit développé.

Interface Web et Middleware

C’est véritablement l’environnement dans lequel le JAVA a vraiment tiré son épingle du jeu, lorsqu’on l’attendait plutôt sur les aspects plus graphiques et grand public. Ce sont les développeurs qui en votant avec leurs pieds ont fait du JAVA un acteur majeur du coté des serveurs. Sa force de ce point de vue réside dans la réponse normalisée qui a été apportées très tôt aux CGI par la plateforme J2EE.

Ses concurrents actuels sont le PHP et les solutions Microsoft. PHP connaît un succès certain en particuliers dans les sites qui ont besoins d’une grande réactivité, mais globalement, les solutions JAVA prennent l’avantage dès qu’il s’agit d’un projet dont l’amortissement est prévu sur plus de 5 ans. Sur le Middleware, IBM s’est aligné avec JAVA et il est pratiquement le seul en lice pour les technologies de demain à ce niveau.

Informatique scientifique

On dépasse progressivement l’époque où c’était avant tout la puissance qui était demandée à l’informatique scientifique. Maintenant, le JAVA est attendu dans toutes les applications scientifiques réellement critiques, comme le pilotage d’un robot sur Mars, pilotage de fusées etc. C’est un phénomène assez nouveau, d’une part les nouveaux chercheurs connaissent ce langage.D’autre parts, on sait mieux intégrer le risque « humain » de programmation.

Informatique embarquée

L’informatique embarquée occupe maintenant une part non négligeable du CA global de ce secteur avec l’avènement du téléphone portable et plus généralement de l’informatique embarquée. Et, surprise, Sun a réalisé une partie non négligeable de son CA l’année dernière sur les jeux embarqués dans les téléphones portables. Pour les mêmes raisons de fiabilité on trouve bénéfice à utiliser ce langage sur des plateformes embarquées.

Runtime et JDK

Sun est le principal acteur du JAVA c'est lui qui détient les droits sur la norme. Cette norme est publique et bien que les sources java des librairies soient publiques, les codes source de la machine virtuelle ne sont pas publics.

Sun fournit deux types de plateforme Java :

JRE

Java Runtime Environnement : c'est ce qu'il faut installer pour faire fonctionner JAVA, ce kit comprend la RunTime ainsi que divers utilitaires qui peuvent être utilisés lors de l'exécution d'un programme, par exemple un gestionnaire de sécurité.

JDK

Java Developpement Kit : Ee kit en plus de la runtime comprend un compilateur, un packager et divers utilitaires qui permettent de créer des programmes JAVA. Il sert pour le developpement. Ce Kit peut être nécessaire pour faire fonctionner certaines applications serveur, en particulier les serveur d'application car il ont besoin d'avoir un compilateur.

La compilation

Pour produire un programme JAVA, il est nécessaire de le compiler. Ainsi le code est transformé en des classes compilées (Qu'on appelle bytecode) qui pourront s'exécuter sur la machine virtuelle.

On peut compiler en utilisant en ligne de commande le programme javac qui fait partie du JDK. Cependant, ce fontionnement est de plus en plus marginal et il existe des IDE gratuites et puissantes comme Eclipse qui effectuent graphiquement ce genre d'opération.

La machine virtuelle

Which pill would you take, the red or the blue?

Pour pouvoir être exécutées les intructions données par le bytecode sont transformées en instructions processeur. Puisque tous les processeurs ne disposent pas du même jeu d'instructions et que certaines opérations sont possibles en un seul cycle d'horloge sur un processeur tandis qu'elles se réalisent en plusieurs instructions sur un autre processeur, le rôle de la machine virtuelle est de convertir un jeu d'instructions propre au processeur.

C'est ici que se trouve la force et la faiblesse du JAVA. La phase d'interprétation du JAVA est celle qui le pénalise le plus par rapport à des langages tel que le C ou C++ qui produisent des exécutables directement en langage machine. En effet, la phase d'interprétation consomme du temps processeur. Les machines virtuelles récentes sont trois fois plus lente que celle en langage processeur. Mais Attention cependant, cela ne veut pas dire que le JAVA est trois fois plus lent car dans un ordinateur il n'y a pas que le processeur qui compte, habituellement ce sont plus les entrées sorties qui consomment le plus de temps.

De plus, ce désavantage en performance sur le papier est compensé par des aspects pratiques au niveau de la programmation. En effet, le langage JAVA est un langage facile à programmer, une bonne conception est souvent la plus grande source de gain en termes de performances. Il ne faut donc pas éliminer le JAVA avec cet argument va-tout que vous entendrez encore dans la bouche de certains vétérans : "Le java n'est pas suffisament performant".

En programmation C ou C++ c'est au programmeur d'allouer et de désallouer de la mémoire. En java on ne parle plus d'allocation de mémoire, mais de référencement d'objet. Pour le programmeur JAVA cette machine virtuelle est une aubaine car elle permet au progammeur de ne plus avoir en tête la représentation mémoire de son programme.

Quand on programme en C, il est facile de penser à allouer de la mémoire sinon ça ne marche pas. Il est par contre beaucoup moins nécessaire de désallouer de la mémoire car le programme fonctionne toujours même s'il consomme plus de mémoire, ce ne sont que de bonne habitudes de développement qui permettent de s'en sortir et il y aura toujours certaines fuites mémoire imprévisibles. C'est assez difficile de s'en apercevoir et difficile à réparer car l'incident se produit parfois longtemps après le développement. En Java, exit ce genre de problème. Ou presque...

Liens utiles

Le site de référence : On y trouve le JDK et tout un tas de tutoriaux (mais c'est en anglais).

The French Hack

Activer HTTPS de httpd sur ubuntu

Update Grub in Ubuntu

Aptitude sur Ubuntu

Installation a travers un proxy

Rechercher un package à partir de son nom

Dump et load avec MySQL

Installer un serveur subversion sur apache sur Ubuntu

deploiement d'un fichier

Bréviaire d'Oracle

Se connecter en tant que sysdba

Créer un USER

Lister toutes les tables

Create a tablespace

Drop a tablespace

Libérer de l'espace disque

Pour créer un tablespace

Exporter des données, créer des dumps oracle :

Importer des données, insérer des dumps oracles :

Créer un user

Affecter les droits à cet utilisateur :

Affecter à cet utilisateur le namespace par défauts

Installer sqlplus de la version XE (client et serveur)

Faire du port forwarding à l'aide de SSH

Externaliser la configuration de ses webapp

Port forwarding à l'aide de iptable

Ip/Port rewriting

Utiliser apache en frontal et forwarder les ports sur un Jetty

Créer un partage Webdav sur Ubuntu 10.4

Installer WebSAV sur apache2

Gérer les droits

Intégration continue avec Hudson et Maven

Environnement

Bénéfices de l'intégrationcontinue

Impacts structurants de l'intégrationcontinue

Contraintes de codage

Test unitaires

Ressources

Contrainte de conception

Au quotidien

Mise en oeuvre

Transaction explicites sous Spring et JPA dans les applications Batch

Changer le splash screen sur Ubuntu 10.4

Utilisation des curseurs dans Mysql

Guide de revue de code

Bonne pratiques de développement

Structuration des projets

Recommandations

Bonnes pratiques de codage de tests unitaires

Bonnes pratiques d'écriture

Merger à l'aide de SVN

Utilisation des patch dans SVN

Méthode en ligne de commande utilisant subversion (Méthode recommandée)

Récuppération du numéro de révision

Checkout de la branche sur laquelle le report est effectué

Report des modifications et fusion

Résolution des conflits

Commit

Méthode se basant sur les fichiers de patch

Méthode sur eclipse

Mysql en case insensitive sur linux Red hat

Install Mysql from the zipped installation

Configuring JNDI Javamail resource over SSL for SMTP

Définition ORACLE

Débuter en JSF

Générer des document openXML Word 2003/2007

JDOM vs DOM et SAX

Configurer maven à travers un proxy

Terminologie de l'informatique

Appliquer des patchs sur des répertoires

La voie du milieu dans le développement informatique

Le bureau des méthodes

Le chef de projet

L'architecte

Le développeur

Ouvrir un document en java

Appfuse pour le développement rapide d'application JAVA

Effectuer une compie de synchronisation

Convertir des fichiers stéréo en mono

Comment parcourir récursivement un répertoire pour appliquer des traitement en C

Bénéfices de l'intégration
continue

Impacts structurants de l'intégration
continue