Netapsys Blog - netapsys

Premier retour après un premier mois chez Netapsys

Fabian Piau — Sun, 18 Oct 2009 13:57:00 +0200

Arrivé depuis maintenant un mois chez Netapsys, je peux déjà dire que j'ai appris beaucoup de choses sur le plan technique et sur le développement. Un peu moins au niveau méthodologique, car il faut dire que j’ai déjà eu quelques expériences en méthodologie agile, notamment en eXtreme Programming : intégration continue (IC) et TDD (test-driven development ou développement dirigé par les tests). Mais, quel plaisir de pouvoir continuer à les utiliser….

Issu d'un parcours MIAGE et ayant des expériences qui découlent plus de la gestion de projet que de la technique pure, j'ai dû m'accrocher. En effet, les collaborateurs ont un bagage technique qui est plutôt "impressionnant". Actuellement, je travaille sur un projet JAVA/J2EE dont le fonctionnel concerne la gestion administrative et financière de projet (en rapport avec ma formation donc).

Je pense qu’entrer chez Netapsys est réellement une très bonne opportunité pour monter en compétences techniques rapidement, de plus sur des bases technologiques et des méthodes plutôt pérennes. Un chef de projet qui maîtrise son sujet sera toujours un meilleur chef de projet, car il pourra quantifier une charge réaliste en fonction de la difficulté technique à réaliser et ainsi, diriger son équipe plus efficacement.

Par exemple, j'avais entendu parler de la notion de design-pattern (Factory et Singleton principalement), mais je ne les avais jamais réellement mis en œuvre ou vu leur véritable intérêt (un peu avec Spring cependant). Exception faite pour le modèle MVC (Modèle-Vue-Contrôleur) qui est pourtant un pattern et qui, aujourd’hui est plus vu comme un standard.

Finalement, les patterns sont donc très utiles, il y en aura toujours un qui sera adapté pour telle ou telle situation. J’ai même été un peu surpris qu’il y en ait autant (un bouquin de plusieurs centaines de pages est toujours disponible à l’entreprise pour s’y référer). Les semaines passées, j'ai appris à utiliser et implémenter le pattern de stratégie, détaillé dans un post précédent.

Tous ces patterns permettent une meilleure généricité de l'application, et donc une meilleure maintenance. L'application à maintenir devient une sorte de mur solide (de préférence ;-), dont les évolutions (ou correction de bogues) ne s'apparentent qu'à l’ajout (ou le remplacement) de quelques briques. Netapsys s'inscrit dans ce contexte d'amélioration continue. Et, comme l'a dit Denis sur son post de l'agile tour, une fois qu'on utilise les pratiques agiles, il est difficile de s'en passer, et pire, de devoir revenir en arrière.

A l'heure d'aujourd'hui, particulièrement en France, les entreprises utilisant des méthodes agiles sont encore assez rares. Grâce à des journées de présentation et de sensibilité à ces nouvelles pratiques (je pense notamment à l'agile tour ou encore, au prochain sujet du JUG Nantes), les choses sont en train de bouger, progressivement, mais sûrement…

Netapsys a 5 ans !

Bénédicte Guignard — Fri, 29 May 2009 15:31:00 +0200

Créée en mai 2004, Netapsys fête cette année son 5ème anniversaire. L’événement a été dignement célébré hier soir par l’ensemble des collaborateurs Netapsys.

C'est à l’Hôtel Bel Ami, à Saint Germain des Prés, que nous avions tous rendez-vous. Accueillis par l’équipe de Chef à la maison, nous avons été priés, à notre arrivée, de nous laver les mains et chacun s’est vu remettre un tablier et une toque. Au programme : la préparation du dîner d’anniversaire de Netapsys!

Deux groupes ont été constitués : le premier a eu la charge de préparer 43 entrées (Gaspacho « minute », chantilly au basilic et ses tartines de saumon fumé) et les légumes « Wok » du plat principal ; le second groupe a eu la responsabilité de préparer les pintades au gingembre confit et les 43 desserts (Moelleux au chocolat sorbet exotique, coulis de fruits rouges et tuile carambar).

Tout le monde s’est prêté au jeu et des talents ont été révélés !

Quelques accidents sont cependant à déplorer : une petite coupure au doigt (mais la pintade a été vaincue et le blessé s’en est tiré avec un petit pansement) ; des éclaboussures de préparation de gâteau au chocolat ; des œufs montés en neige à la force des poignets… devenus douloureux…

Mais, le résultat en valait la peine !

La preuve en images :

Tests JUnit4 combiné avec Spring et Spring MVC en mode transactionnel

Abderrazek CHINE — Fri, 17 Apr 2009 16:18:00 +0200

Le titre de ce billet montre bien l'étendue des thèmes variés qui seront traités. Il a pour objectif d'illustrer, à l'aide d'un exemple assez complet et proche des cas réels, la mise en place des tests, en mode transactionnel, pour les différentes couches applicatives. Ainsi les vraies difficultés rencontrées par les développeurs seront évoquées.
Le billet traite JUnit4 enrichi avec les annotations de Spring 2.5+ et ses lanceurs pour exécuter facilement les tests. Des illustrations en mode transactionnel vous sont proposées à la fin de ce billet.
Le framework JUnit est l'oeuvre conjointe de Kent Beck (créateur de XP) et Erich Gamma (auteur des Design Patterns).
Avec la version 4, JUnit tente de rattraper son retard sur Testng tout en gardant la compatibilité avec JUnit3x ainsi qu'une parfaite intégration aux éditeurs Eclipse, Netbeans, ...
Avec les lanceurs de spring, les tests deviennent plus attrayants. Spring encourage ainsi à adopter l'approche TDD "Test Driven Design" ou "Test-First Developpment".
Notez que le jdk5+ est nécessaire pour certaines parties de code Java. Les commentaires dans le code java le mentionnent au bon endroit.

Le framework JUnit est l'oeuvre conjointe de Kent Beck (créateur de XP) et Erich Gamma (auteur des Design Patterns).
Avec la version 4, JUnit tente de rattraper son retard sur Testng tout en gardant la compatibilité avec JUnit3x ainsi qu'une parfaite intégration aux éditeurs Eclipse, Netbeans, ...

La pratique des tests unitaires est l'un des principes des méthodes agiles. Il semble que tous les nouveaux frameworks renforcent le principe de testabilité de toutes les couches applicatives.
Avec JUnit4 et Spring, les tests, en particulier d'intégration, deviennent aisés. Ceux ayant pratiqués les tests savent bien les efforts nécessaires afin de tester certaines couches( par exemple, la couche de persistance ou DAO).
Citons au passage, qu' un critère majeur permettant de juger de la suffisance des tests peut être :
L'investissement fait en tests doit être égal à celui passé sur le design. Et si le design répond facilement au changement alors les tests sont suffisants.
L'un des avantages des tests est d'avoir un retour (feedback) rapide et beaucoup moins cher sur les réglages à apporter au logiciel et ainsi d'anticiper les anomalies.
Le second avantage des tests (unitaires et d'intégration) est de limiter le nombre d'itérations (en phase recette/production) de mise en conformité du logiciel.
Et, par conséquent, de réduire son coût total. Signalons qu'en phase de mise en recette/production les personnes impliquées sont de diverses compétences d'où le coût économique élevé d'une itération à ce stade!
La figure suivante résume les objectifs des différents types de tests pour un projet.
La bonne compréhension de ce billet nécessite d'avoir certains pré-requis énoncés plus loin. A défaut, au préalable, lire article sur le blog Netapsys . Par contre, l'utilisation de Spring avec JUnit4 n'exige en aucun cas de maîtriser Spring.

Dans l'exemple détaillé plus loin, Spring 2.5 allège considérablement la configuration XML.
De plus, les principes "ZERO CONFIGURATION" et/ou "CONVENTION OVER CONFIGURATION" permettent d'alléger plus les fichiers de configuration xml.
La présentation de ce billet est divisée en trois grandes parties:

Créer une application Web Java JEE avec Maven2, SpringMVC et ses annotations (en particulier @Controller) (Voir article sur le blog Netapsys pour les étapes de création d’un projet sous eclipse avec maven2) ;
Mettre en place, via le framework JUnit4.x, des tests unitaires et des tests d'intégration couvrant l'ensemble des couches applicatives (couches Dao, Service et Web en SpringMVC) ;
Enfin, exécution des tests en mode transactionnel. Les codes sources présentés sont disponibles en annexe

PREREQUIS

Les pré-requis suivants aideront à lire facilement ce billet. Mais tous ne sont pas nécessaires à sa compréhension.

Connaissance des applications Web dans le monde JEE (servlet, jsp..) ;
Connaissance sommaire de Spring, Spring MVC avec ses annotations ;
Connaissance sommaire de JUnit4.x avec ses annotations ;
Connaissance sommaire de la notion de transaction.

ETAPE 1. Application Web avec Spring MVC

Pour toute la suite, l’application Web exemple sera nommée «spring-mvc-webapp». C’est le nom de la servlet frontale dans le fichier web.xml.
Commençons par configurer le fichier web.xml dont voici le contenu (certaines lignes peuvent encore être simplifiées mais sont laissées ici pour une meilleure compréhension) :

<web-app> 
<context-param> 
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/spring-mvc-webapp-servlet.xml, classpath:/spring.xml
</param-value>
</context-param> 
 
<listener> 
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
<!-- déclare la servlet frontal -->
<servlet> 
<servlet-name>spring-mvc-webapp</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet> 
 <!-- les requêtes se terminant par .html sont servies par cette servlet --> 
<servlet-mapping> 
<servlet-name>spring-mvc-webapp</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping> 
</web-app>

Notons que l'arborescence du projet sera donnée dans l'annexe de ce billet.
La partie 'contextConfigLocation' sera explicitée plus loin : on reviendra en détail sur les fichiers spring*.xml.
Le «listener» permet de configurer le contexte du Spring MVC.
Le bloc "<servlet>...</servlet>" permet d'identifier la servlet frontale de Spring MVC chargée de répondre à toutes les requêtes (*.html) d'un client de l’application Web.
La section suivante détaille le fichier «spring-mvc-webapp-servlet.xml», nommé ainsi conformément à la convention.

ETAPE 2. Configuration de Spring MVC

Le fichier «spring-mvc-webapp-servlet.xml» doit contenir ces lignes :

<?xml version="1.0" encoding="UTF-8"?>
<!-- Fichier de conf du contexte d'application pour Spring (fichier nommé spring-mvc-webapp-servlet.xml selon la convention. -->
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
				default-autowire="byName">
	<!-- - Tous les controlleurs sont automatiquement détectés grâce à l'annotation @Controller.
		- On définit ici dans quel package le post processor doit chercher ces beans annotés.	-->
 
  	<context:component-scan base-package="com.netapsys.fr.springmvc.web"/>	  	
 
	<!-- Activates various annotations to be detected in bean classes: Spring's
		@Required and @Autowired, as well as JSR 250's @PostConstruct,@PreDestroy and 
		@Resource (if available) and JPA's @PersistenceContext & @PersistenceUnit.
	-->
	<context:annotation-config/>
	<!--
		- Les controlleurs de cette application fournissent une annotation @RequestMapping 
		- Ils peuvent être déclarés de deux manière différentes:
		-  Au niveau de la classe : 
		-      par exemple @RequestMapping("/addVisit.html")
		-      Pour ce type de controlleurs on peut annoter les méthodes pour une requete Post ou Get,
		- Au niveau de chaque méthode. Différents exemples seront fournis.
	-->
	<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
	<!--
		Ceci est le view resolver, il permet de définir la technologie de vue utilisée et comment
		sélectionner une vue. On prendra ici la solution la plus simple : elle permet de mapper 
		le nom de la vue retournée avec la sélection d'une jsp. Ex. : si le nom de la vue retournée est "hello" alors on utilisera le fichier
		WEB-INF/jsp/hello.jsp pour construire la vue. 
	-->
	<bean 
	 class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
	 p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/>
</beans>

En dehors des commentaires et explications, ce fichier contient peu de lignes. Et même si le projet continue à grossir, ce fichier de configuration n'évolue que très peu.
Soulignons que l’emploi des namespaces (par exemple mlns:context) réduit énormément la verbosité de la configuration XML de Spring.
La dernière ligne définit la vue retournée en réponse à une requête http.
Remarque importante: dans le fichier web.xml déjà présenté, la variable «contextConfigLocation» pointe, entre autres, vers le fichier "spring.xml". Et ceci afin que le contexte de l’application Web charge aussi d’autres beans nécessaires. Attention, en l'absence de cette indication, vous seriez en face d’exceptions difficiles à déchiffrer !
La classe du "controller de SpringMVC" est nommée "ClientControllerSpringMVC.java". Le controller se charge de traiter les requêtes transmises par la servlet dispatcher de SpringMVC en réponse aux requêtes http du client de l'application web.

Controller de spring MVC
Le code de la classe multi-controller Spring mVC "ClientControllerSpringMVC.java" est comme suit:

package com.netapsys.fr.springmvc.web;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.support.SessionStatus;
import com.netapsys.fr.springmcv.entites.Client;
import com.netapsys.fr.springmvc.exceptions.MyException;
import com.netapsys.fr.springmvc.service.MyService;
import com.netapsys.fr.springmvc.tb.constants.Constants;
 
@Controller("clientControllerSpring")
public class ClientControllerSpringMVC {
	private MyService myService;
	@Autowired
	public void setMyService(MyService myService) {
		this.myService = myService;
	}
	final Logger logger=Logger.getLogger(getClass().getName());
	/**
	 * Handler de la méthode Get pour l'URL /getClientSpringMVC.html. 
	 * @param nom le nom du theme affiché dans la vue.
	 * @param prenom 
	 * @param model une map de toutes les données qui seront utilisables dans la vue 
	 * @return le <code>Constants.SUCCESS or Constants.ECHEC</code> nom de la vue qu'il faudra utiliser.
	 */
	@RequestMapping(value="/getClient.html",method = RequestMethod.GET)
	public  String getClient(@RequestParam(value=Constants.ATTRIBUTE_NAME,required=true) String nom,
			@RequestParam(value=Constants.ATTRIBUTE_LASTNAME,required=false) String prenom,ModelMap model) {
		Client client=myService.getClient(nom, prenom);
		if(client!=null )  {
			logger.info(">>Client '"+prenom+" "+nom+"'  existe.");
			model.addAttribute("client",client);
			return Constants.SUCCESS; 
		}else {
			model.addAttribute("errorMsg", "Client '"+prenom+" "+nom+"' inexistant");
			return Constants.ECHEC;
		}
	}
	@RequestMapping(value="/createClient.html",method = RequestMethod.GET)
	public String createClient(	@RequestParam(value=Constants.ATTRIBUTE_NAME,required=true) String nom,
			@RequestParam(value=Constants.ATTRIBUTE_LASTNAME,required=false) String prenom,	ModelMap model) {
		Client client=null;
		try {
			client=myService.createClient( nom, prenom);
		} catch (MyException e) {e.printStackTrace();}			
		model.addAttribute("client",client);
		logger.info("client created="+client);
		return Constants.SUCCESS;
	}
	@RequestMapping(value="/updateClient.html",method = RequestMethod.POST)
	public String updateClient(	@ModelAttribute("client") Client client,BindingResult result, SessionStatus status) {
		logger.info("Client to update "+client.toString());
		myService.updateClient(	client.getCliId(), client.getCliNom(),client.getCliPrenom());
		status.setComplete();
		logger.info(">>>Client update OK");
		return null;
	}
}

Notez que la classe est annotée avec le stéréotype @Controller. Ainsi ses méthodes vont être analysées par la servlet dispatcher pour traiter toutes les requêtes(*.html). L'auto-détection de Spring2.5 va scanner, via <context:component-scan> du fichier spring-mvc-webapp-servlet.xml, les beans dans les packages mentionnés.
Noter également la présence d'autres stéréotypes @repository ou @Service qui sont commentés dans le code java.
Mises à part les annotations @RequestMapping et @RequestParam, le "controller" ne fait qu'appeler les méthodes de la couche service.
Cette dernière couche est détaillée ci-après. Mais avant cela, la section suivante présente le contenu du fichier spring.xml.

ETAPE 3. Configuration Spring des beans des couches DAO et Service

Le fichier de configuration Spring nommé spring.xml (pas de convention ici !) sert à déclarer les beans métier qui seront consommés par l’application Web. Il indique les packages java à scanner pour l'auto-injection de ces beans. Enfin, il déclare une dataSource pour la couche DAO.

<?xml version="1.0" encoding="UTF-8"?>
<!-- spring.xml -->
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xmlns:aop="http://www.springframework.org/schema/aop"
		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/tx/spring-aop-2.5.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
		__default-autowire__="byName">
	<!--
		Activates various annotations to be detected in bean classes: Spring's
		@Required and @Autowired, as well as JSR 250's @PostConstruct,
		@PreDestroy and @Resource (if available) and JPA's @PersistenceContext
		and @PersistenceUnit (if available).
	-->
	<context:annotation-config/>
 
	<context:component-scan base-package="com.netapsys.fr.springmvc.dao"/>
        <context:component-scan base-package="com.netapsys.fr.springmvc.service"/>
 
	<bean id="dataSource" 
		class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName"
			value="com.mysql.jdbc.Driver">
		</property>
		<property name="url"
			value="jdbc:mysql://localhost:3306/test">
		</property>
		<property name="username" value="root"></property>
		<property name="password" value="root"></property>
	</bean>
</beans>

ETAPE 4. Classes DAO et Service

- Couche DAO :

Notez que cette couche utilise deux classes beans d'entités ( Client.java et Personne.java). Leurs codes, simples, sont donnés en annexe.

Le code de l'interface IDao.java contient :

package com.netapsys.fr.springmvc.dao;
import com.netapsys.fr.springmcv.entites.Client;
import com.netapsys.fr.springmvc.exceptions.MyException;
public interface IDao  {
  boolean isExistId(String id);
  boolean findByName(String nom);
  Client getClient(String nom);
  Client getClient(String nom,String prenom);
  Client getClient(long id);
  Client createClient(String nom, String prenom) throws MyException;
  Client updateClient(long id,String nom, String prenom);
  void deleteClient(long id);
}

Et l'implémentation de cette interface est faite dans la classe DaoImpl.java qui contient les lignes suivantes :

package com.netapsys.fr.springmvc.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.simple.ParameterizedRowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import org.springframework.stereotype.Repository;
import com.netapsys.fr.springmcv.entites.Client;
import com.netapsys.fr.springmvc.tb.constants.Constants;
@Repository /** @Repository  un marqueur Spring pour, entre autres, auto-translater les exception de la couche de persistance.**/
public class DaoImpl implements IDao{
	final private Logger logger = Logger.getLogger(getClass().getName());
	/**
	 * spring template for jdbc (jdk 5ou+)
	 */
	private SimpleJdbcTemplate jt=null;	
	@SuppressWarnings("unused")
	private DataSource dataSource;
	@Autowired
	public void setDataSource(DataSource dataSource) {
		//Recommandation de spring: Initialiser SimpleJdbcTemplate ici avec new lorsqu'une seule datasource est nécessaire!
		jt=new SimpleJdbcTemplate(dataSource);
	}
	/* (non-Javadoc)
	 * @see com.netapsys.springmvc.metier.IService#getClient(java.lang.String)
	 */
	public Client getClient(String nom) {
		return getClient(nom,null);
	}
	public Client getClient(long id) {
		return getClient( String.valueOf(id)  );	
	}	
	public Client getClient(String nom, String prenom) {
		String sql=Constants.SQL_REQUETE_CLIENT + "  WHERE upper(CLINOM)='"+nom.toUpperCase()+"'";
		if(prenom!=null && !"".equals(prenom)) 
			sql+=" AND upper(CLIPRENOM)='"+prenom.toUpperCase()+"'";
		if(!findByName(nom) ) {
			return (Client)null;	//Si nom n existe pas dans bd renvoie null;
		}
		ParameterizedRowMapper<Client>  mapper=new ParameterizedRowMapper<Client>(){
			public Client mapRow(ResultSet rs,int rowNm) throws SQLException{				
				return populateClient(rs);				
			}
		};
		Client client=jt.queryForObject(sql, mapper);
		logger.info("get Client = "+client);
		return client;
	}
	private Client populateClient(final ResultSet rs)	throws SQLException {
		if(rs==null) return null;
		Client client=new Client();
		client.setCliId (  rs.getLong("cliId")      );
		client.setNom   (  rs.getString("cliNom")   );
		client.setPrenom ( rs.getString("cliPrenom"));
		return client;
	}
	/* (non-Javadoc)
	 * @see com.netapsys.springmvc.metier.IDao#createClient(long, java.lang.String, java.lang.String)
	 */
	public Client createClient( String nom, String prenom) {
		Client client=new Client();
		client.setNom(nom);
		client.setPrenom(prenom);
		try{			
			jt.update( Constants.SQL_REQUETE_INSERT_CLIENT+ "'"+nom+ "' , '"+prenom+"'" +")" );
			long id=jt.queryForLong("select LAST_INSERT_ID()"); 			//Mysql retrieve the last id inserted
			client.setCliId(id);
			return client;
		}catch(DataAccessException e){
			logger.error( e.getMessage());
			return null;
		}
	}
	/* 
	 * @see com.netapsys.springmvc.metier.IService#exist(java.lang.String)
	 */
	public boolean isExistId(String id) {
		final String sql = Constants.SQL_REQUETE_COUNT_CLIENT+" WHERE cliId='" +id + "'";
		int count = jt.queryForInt(sql);
		return count > 0 ? true : false;
	}
	public boolean findByName(String nom) {		
		return findByName(nom,null);
	}
	public boolean findByName(final String nom,final String prenom) {		
 
		String sql = Constants.SQL_REQUETE_COUNT_CLIENT+
				" WHERE UPPER(cliNom)='" +nom.toUpperCase() + "'";
		if(prenom!=null && !"".equals(prenom))
			sql+=" AND UPPER(CLIPRENOM)='"+prenom.toUpperCase() + "'";
		int count = jt.queryForInt(sql);
		return count > 0 ? true : false;
	}
	public void deleteClient(long id) {
		final String sql=Constants.SQL_DELETE_ALL_CLIENT+" WHERE cliId='"+ id + "'";		
		jt.update(sql);
	}
	public Client updateClient(long id, String nom, String prenom) {
		Client client=new Client();
		client.setCliId(id);
		client.setCliNom(nom);
		client.setCliPrenom(prenom);
		final String sql="update Client set clinom='"+
				nom+"', cliprenom='"+prenom+"' WHERE cliId='"+id+"'";
		logger.info("nb rows updated="+jt.update(sql) );
		return client;
	}
}

- Couche service :

Enfin, la couche service contient, en dehors de son interface identique à celle de IDao, la classe d'implémentation nommée MyService.java dont voici son code:

package com.netapsys.fr.springmvc.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.netapsys.fr.springmcv.entites.Client;
import com.netapsys.fr.springmvc.dao.DaoImpl;
import com.netapsys.fr.springmvc.exceptions.MyException;
@Service()
public class MyService implements IService{
	private static final long serialVersionUID = 1L;
	/**	 * @see com.netapsys.fr.springmvc.dao.DaoImpl	 */
	private DaoImpl daoImpl;
	@Autowired
	public void setDaoImpl(DaoImpl daoImpl) {
		this.daoImpl = daoImpl;
	}
	public Client getClient(String nom, String prenom) {
		return daoImpl.getClient(nom, prenom);
	}
	public boolean isExistId(String id) {	
		// Valider les regles de gestion .....if id is not int/long...
		return daoImpl.isExistId(id);
	}
	public boolean findByName(String nom) {
		return daoImpl.findByName(nom);
	}
	public Client getClient(String nom) {
		return daoImpl.getClient(nom);
	}
	public Client createClient( String nom, String prenom) throws MyException {
		return daoImpl.createClient( nom, prenom);
	}
	public void deleteClient(long id) {		
		 daoImpl.deleteClient(id);
	}
	public Client getClient(long id) {
		return daoImpl.getClient(id);
	}
	public Client updateClient(long id, String nom, String prenom) {
		return daoImpl.updateClient(id, nom, prenom);
	}
}

La couche service est là pour appeler les méthodes de la couche DAO. Et c'est dans la couche service que l'on gère l'aspect transactionnel mais également les règles métier spécifiques. On peut faire de même pour tous les apsects transverses tels que les logs et les mesures de temps d'exécution.

ETAPE 5. Fichiers jsp

Le fichier index.jsp ne fait que rediriger la requête vers l'url /createClient.html.

La requête /createClient.html est interceptée par la servlet frontale de SpringMVC, qui à son tour décide de l'action (méthode) à appeler dans le "controller" nommé "ClientControllerSpringMVC" et qui décide ensuite de la vue à rendre en réponse à cette requête. Dans notre cas, c'est la méthode "public String createClient" de la classe "ClientControllerSpringMVC.java" qui sera appelée. Celle-ci, en cas de succès renvoie la chaîne "success" stockée dans Constants.SUCCESS de la classe utilitaire Constants. C'est cette chaîne qui permet de traduire la vue gérant la présentation de la réponse, dans notre cas "success.jsp".

Voici donc les quelques lignes de index.jsp:

[jsp]
<html>
<head>
<title>Spring mvc sample</title>
</head>
<body>
<%
    final String urlAction="/createClient.html?";
	final String nom = request.getParameter("name");
	final String prenom = request.getParameter("lastName");
	if (nom != null && !"".equals(nom))
		response.sendRedirect(request.getContextPath()
				+ urlAction+"name=" + nom + "&lastName"
				+ prenom);
	else
		response
				.sendRedirect(request.getContextPath()
						+ urlAction+"name=nom007&lastName=prenom007");
%>
</body>
</html>

Le fichier success.jsp:

[jsp]
<body>
<h2>Edition de la fiche client créé   </h2><br />
<% final String url=request.getContextPath()+"/updateClient.html";%>
<form:form commandName="client" action="<%=url %>" method="post">
<table>
<tr><td></td>
<td><form:hidden  path="cliId" /></td>
</tr>
<tr><td>Nom:</td>
<td><form:input tabindex="1" autocomplete="true"  path="cliNom" /></td>
</tr>
<tr><td>Prénom:</td>
<td><form:input tabindex="2" autocomplete="true"  path="cliPrenom" /></td>
</tr>
<tr<td colspan="2">
<input type="submit" value="Valider" />
</td>
</tr>
</table>
</form:form>
</body>
</html>

Enfin, la source du fichier error.jsp:

[jsp]
<body>
<%  String msgError=(String)request.getAttribute("errorMsg"); %>
<br /><h2> </h2><br /><b><%=msgError%></b>
</body>
</html>

Dans success.jsp, l'action du tag "<form:from" pointe sur /updateClient.html avec la méthode http "POST". La méthode "public String updateClient" du "controller" renvoie constamment "null". Ainsi, la vue utilisée dans ce cas est /WEB-INF/jsp/updateClient.jsp conformément aux déclarations du fichier spring-mvc-webapp-servlet.xml.
Le fichier updateClient.jsp contient ces lignes:

[jsp]
<body>
<h2>Page Modification client</h2><br/>
<% 
    final String path=request.getContextPath();
    final String urlAction=path+"/updateClient.html";
%>
<form:form commandName="client" action="<%=urlAction %>" method="post">
<table border=0>
<tr>
<td colspan="2"><form:hidden  path="cliId" id="id"/></td>
</tr>
<tr>
<td>Nom:</td>
<td><form:input  autocomplete="true"  path="cliNom" /></td>
</tr>
<tr>
<td>Prénom:</td>
<td><form:input  autocomplete="true"  path="cliPrenom" /></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="Valider" />
</td>
</tr>
</table>
</form:form>
</body>
</html>

ETAPE 6. Tests de l'application web
Pour tester l'application web ainsi complétée, nous allons lancer une console dos, puis se positionner dans le répertoire du projet et lancer la commande :

[sh]
mvn jetty:run

S'assurer que la base Mysql nommée test (contenant une table client avec trois champs cliId, cliNom et cliPrenom) est en service.
Puis lancer le navigateur web avec l'url "http://localhost:8080/spring-mvc-webapp/index.jsp".
Vous devez obtenir la figure ci-contre .

ETAPE 7. Classe de test du controlleur SpringMVC

La classe JUnit4, nommée "ClientControllerSpringMVCTest.java", permet de tester le "controller" de SpringMVC. Elle est constituée des lignes suivantes :

/*-- Attention, les puristes de Junit ne verront pas les assert ici!!!!!! */ 
package com.netapsys.tests.springmvc.web.tests;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.ui.ModelMap;
import com.netapsys.fr.springmvc.tb.constants.Constants;
import com.netapsys.fr.springmvc.web.ClientControllerSpringMVC;
@ContextConfiguration(locations={"classpath:/config/spring-mvc-webapp-tests.xml","classpath:/config/spring-test.xml"})
@RunWith( SpringJUnit4ClassRunner.class) //to activate autowiring injection dependence
public class ClientControllerSpringMVCTest  {
	final static Logger logger =Logger.getLogger(ClientControllerSpringMVCTest.class.getClass().getName());
	/**
	 * Attribute in url, ex. "/getClient.html?name=Agent007
	 */
	final String NAME2TEST="Agent007";
	final String LASTNAME2TEST="007";
	private static ModelMap model;
	protected  ClientControllerSpringMVC clientControllerSpring;
	/**
	 * auto dependency injection par spring du controller dans les tests
	 */
	@Autowired
	public void setClientControllerSpring(ClientControllerSpringMVC clientControllerSpring) {
		this.clientControllerSpring = clientControllerSpring;
	}
	@BeforeClass() 	public static void testAvantTout(){	model = new ModelMap();	}
	@AfterClass() public static void apresTousLesTests(){	model.clear();	}
	@Before public void initAvant(){
		if(clientControllerSpring!=null)	/** testons que spring injection est ok*/
		logger.info("\n\tclientControllerSpring is correctly initialized!");
	}
	@After public  void testApres(){}
	@Test
	public void testGetClient() {	
		//create or get client with given nom. if not exist create it with nom & prenom 
		final String str=clientControllerSpring.getClient(NAME2TEST, LASTNAME2TEST, model);
		if((Constants.SUCCESS).equals(str))	logger.info( model.get("client") );
	}		
}

Les parties importantes pour la compréhension des lanceurs de spring (annotés par @RunWith) sont bien documentées dans le code.
L'annotation @RunWith définit le lanceur spring qui enrichit considérablement les tests JUnit4 avec les fonctionnalités supplémentaires ( ex. l'auto-injection) offertes par Spring.
Spring offre aussi des annotations inexistantes dans JUnit4 utiles à l'exécution de ces tests.
Signalons que la ligne:

@ContextConfiguration(locations={"classpath:/config/spring-mvc-webapp-tests.xml","classpath:/config/spring-test.xml"})

renvoie à deux fichiers de configuration de springMVC et de spring qui sont donnés en annexe. Ces deux fichiers sont identiques, à une déclaration près, aux fichiers spring-mvc-webapp-servlet.xml et spring.xml explicités auparavant. La ~~seule différence~~ est l'ajout de la déclaration de la transaction dans spring-test.xml:

<!-- transaction -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	 <property name="dataSource" ref="dataSource"/>
	</bean>

Ainsi, avec le bean "transactionManager" les tests en mode transactionnel ci-après deviennent possibles comme illustré à l'étape suivante.

ETAPE 8.Classe de test en mode transactionnel

Les deux figures suivantes donnent le code de la classe MyServiceTest.java. Cette classe comporte toutes les indications pour excéuter les méthodes en mode transactionnel :

package com.netapsys.tests.springmvc.web.tests;
import java.util.Random;
import org.apache.log4j.Logger;
import org.junit.*;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.AfterTransaction;
import org.springframework.test.context.transaction.BeforeTransaction;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.netapsys.fr.springmcv.entites.Client;
import com.netapsys.fr.springmcv.entites.Personne;
import com.netapsys.fr.springmvc.exceptions.MyException;
import com.netapsys.fr.springmvc.service.MyService;
/** * *******************************************************************
 * NOTE IMPORTANTE: defaultRollback à true ANNULE TOUTES LES ACTIONS DANS LA BASE!
 * ******************************************************************** */
@ContextConfiguration(locations={"classpath:/config/spring-mvc-webapp-tests.xml","classpath:/config/spring-test.xml"})
@RunWith( value=SpringJUnit4ClassRunner.class ) //indispensable
@TransactionConfiguration(transactionManager="transactionManager",defaultRollback=true)
public class MyServiceTest  {
	private final Logger logger = Logger.getLogger(getClass().getName());
	/**	 * AUTO INJECTION PAR SPRING    */
	private  MyService myService;
	@Autowired 	public void setMyService(MyService myService) {
		this.myService = myService;
	}
	@BeforeClass	public static void beforeClasse(){}
	@Before()	public void avantChaqueTest(){
		if(myService==null) logger.error("Y a vraiment un probleme avec spring");//verifie que l'auto injection de spring est ok
		logger.info(">>>Before test...(this is in transaction scope)");	
	}
	@After() public void apresChaqueTest(){	logger.info(">>>After test...(this is in transaction scope)");	}
	@BeforeTransaction() 
	public void avantTransaction(){	logger.info(">>>Avant chaque transaction");}
	@AfterTransaction public void apresTransac(){ logger.info(">>>Apres chaque transaction");}
	/** *  PREMIER TEST  ****/
	@Test @Transactional (propagation=Propagation.REQUIRED)
	public void testCreateClient() {
		final String nom =giveRandomName("Agent007test");
		final String prenom=giveRandomName("007test");
		Client client=null;
		try{
			client=myService.getClient(nom,prenom);
			if(client!=null){
				logger.warn("client "+client +" existe donc ne sera pas créé");
				throw new MyException("Client existe!");
			}
			client=myService.createClient( nom, prenom);
			if(client!=null)logger.info("\n>>>Client :'"+client.toString()+"' is created!");
		}catch(MyException se){
			logger.error(">>>Client exist!\t"+se.getMessage());
		}
	}
	/**	 *  2eme test : 	 */
	@Ignore @Transactional(readOnly=true) 
	public void testGetClient(){
		logger.info("\n>>>3eme test getClient.");
		final String NAME="nom007nnn";
		final String LASTNAME="prenom007nnn";
		Personne client=myService.getClient(NAME,LASTNAME);
		if(client!=null)
			logger.info(">>>>"+client.toString());
		else 
			logger.info("Client '"+NAME+"' not exist!");
	}
	private String giveRandomName(final String prefix) {
		final Random random=new Random();		
		return prefix+random.nextInt(100);
	}
}

Pour tester ces différentes classes, lancer la commande "mvn test".
Les commentaires du code et les traces de log4j à retrouver après l'exécution sont très explicites. Ils permettent de voir qu'en positionnant le "defaultRollback" de l'annotation spring "@TransactionConfiguration" à true, ces tests simulent la création d'un client dans la base.
C'est à dire, qu'un rollback est fait à chaque test. On peut modifier le paramètre "defaultRollback=false", et les transactions insèrent bien des clients dans la base.
Mais généralement, en mode test, le defaultRollback est positionné à true.
L'annotation de Spring @Autowired gère fort bien l'auto-injection si on observe la règle suivante : Annoter, avec les @Autowired, toujours les méthodes setters/getters et positionner dans les fichiers de configuration de spring le defaut-autowired à byName afin d'anticiper sur des exceptions indéchiffrables.
C'est là que l'on prend conscience de l'apport de Spring au framework de test JUnit. Juste quelques annotations en plus et les tests deviennent transactionnels.
Les retours bénéfiques de ces tests sont considérables.

ETAPE 9. Conclusion

Combiner Spring 2.5+ et JUnit4 permet d'avoir sous la main un framework de test puissant facilitant la mise en place des tests unitaires et d'intégration. Bien que l'apprentissage exige un léger effort, une fois ces deux frameworks maîtrisés, l'efficacité et le gain économique sont énormes.
Enfin, la qualité du livrable au client ne sera que meilleure.
Observons, en particulier, dans les classes de tests en mode transactionnel, le confort qu'apporte Spring à JUnit4.
Les annotations Spring @TransactionConfiguration et @Transactional rendent les transactions à la portée de tout le monde.
Dans un prochain billet, je reviendrai sur les tests paramétrés dans Spring.

ETAPE 10. Annexes (pom et codes sources)

La figure ci-après illustre l'arborescence du projet
.

Le fichier zip contenant le projet ainsi que les détails du pom.xml sont joints à ce billet.

[Retour sur la conférence] Java / .NET : Qui dominera le marché dans 10 ans ?

Sébastien Hébert — Fri, 20 Mar 2009 12:46:00 +0100

Le 22 janvier dernier s'est déroulée une conférence sur le thème Java VS .NET. Plusieurs intervenants étaient présents dont SODIFRANCE, ACCENTURE et bien entendu NETAPSYS.

Petit retour sur la soirée !

Une chose est sûre : en France et globalement en Europe, Java est bien plus présent que .NET technologiquement parlant. S'il est vrai que .NET grignote petit à petit des parts de marché à Java, personne ne peut répondre avec certitude à cette question.

SODIFRANCE prévoit la disparition du développeur.

SODIFRANCE prétend que le métier de développeur est amené tôt ou tard à disparaitre d'une certaine manière compte-tenu de la percée de l'approche MDA (Model Driven Architecture) où le principe consiste à générer le code à partir de la modélisation UML du modèle, De plus, les intervenants considèrent que parler de Java et de .NET uniquement n'est pas représentatif du marché puisqu'à juste titre beaucoup d'applications tourneront encore sur COBOL, et ce peut-être même dans 10 ans.

ACCENTURE mise sur une démarche SOA.

Même si ACCENTURE ne prétend pas pouvoir non plus répondre à la question du "Qui gagnera ?", les intervenants ne cachent pas cependant leur préférence qui va directement à Java / JavaEE. Cette préférence s'explique par le fait que Java soit davantage tourné vers l'Open Source et les standards contrairement à .NET jugé trop enfermé dans la sphère Microsoft. De plus, de nombreux éditeurs comme SAP ou Oracle ont choisi de faire tourner leurs solutions logicielles sur des socles Java (Oracle ESB pour Oracle et Netweaver pour SAP). ACCENTURE estime que les technologies gagnantes de demain seront celles qui répondront au mieux à la problématique posée par la démarche SOA : "comment concevoir de nouvelles applications qui s'intègrent dans une stratégie de rationalisation du SI en évitant le plus possible l'effet SILO Applicatif ?"

NETAPSYS thinks Java && .NET

NETAPSYS a, quant à elle, adopté une approche plus technique et finalement les trois présentations ont été assez complémentaires. Après quelques rappels sur l'historique de Java et de .NET, je me suis penché sur les raisons légitimes qui poussent les développeurs à opposer Java et .NET. Le premier bilan est que la technologie importe peu dans le sens où l'une et l'autre permettent d'arriver au même résultat.

Toutefois, il semblerait que les développeurs préfèrent Java à .NET pour le développement côté serveur étant donné la pérennité de la technologie par rapport à .NET et l'existence de nombreux frameworks qui ont su s'imposer dans l'Entreprise. Il n'y a qu'à voir Struts, Spring, JSF ou encore Hibernate pour la persistance.

A contrario, il semblerait que .NET soit la référence quant au développement d'applications visuellement riches. Microsoft investit en effet énormément sur les IHM (Windows Forms, WPF, Silverlight).

La présentation s'est terminée sur le fait qu'il ne fallait pas nécessairement penser Java ou .NET mais peut-être les deux !!! Microsoft et Sun travaillent en effet depuis quelques temps sur la manière d'améliorer l'interopérabilité entre les deux mondes, même si et on s'en doute, la volonté de chacun est d'attirer le plus de développeurs de son côté.

Microsoft, via Windows Azure, et sa future plateforme de Cloud Computing, flirte du côté de Java en proposant une API pour Azure. De la même manière, l'éditeur a annoncé un plugin pour Eclipse concernant le développement d'applications Silverlight.

De son côté, Sun a instauré la pile de Services Web Metro intéropérable avec WCF - Windows Communication Fourndation - disponible depuis .NET 3.

Voilà, c'est tout pour le moment. Si le sujet intéresse du monde, je vous propose, comme Marine me l'a suggéré, de vous refaire la présentation afin de bénéficier de vos retours et peut-être de lancer un grand débat !

La nouvelle version du site www.netapsys.fr est en ligne !

Bénédicte Guignard — Fri, 13 Mar 2009 15:00:00 +0100

La nouvelle version du site Internet de Netapsys a été mise en ligne le 11 mars 2009. Ce sont les équipes Netapsys qui accueillent, dès la première page, les visiteurs du site.

Le premier site Internet de Netapsys a été mis en place en 2004, à la création de la société. Cette première version était statique. Après une seconde version sous OpenCMS, réalisée en 2006, le contenu et l’ergonomie du site avaient de nouveau besoin d’être actualisés.

C’est la plateforme de contenu SPIP qui a été retenue pour le développement du nouveau site. Le développement, en PHP, a été confié à Denis, ingénieur Netapsys de l’agence de Nantes. SPIP (Système de Publication pour l'Internet Partagé) est un logiciel libre destiné à la production de sites Web, de type CMS. SPIP possède une communauté active sur le net et on trouve de la documentation assez facilement. Pour en savoir plus, vous pouvez visiter http://www.spip-contrib.net. L’outil SPIP, grâce à son interface très simple d’utilisation, permet d’administrer le site de manière dynamique et de le tenir facilement à jour. Pour preuve, j’ai moi-même rédigé et mis en ligne les articles ! :-) La réalisation et la mise en ligne du site illustre la parfaite collaboration entre les équipes Netapsys de Paris et de Nantes.

Sur notre nouveau site Internet vous trouverez toutes les informations concernant Netapsys (la société, ses chiffres clés, son savoir-faire, sa culture, ses projets…) et ses actualités (ses dernières références, sa newsletter, ses offres d’emploi…). Le tout est mis en graphisme par le studio Beeart. Et, pour illustrer ce nouveau site, Netapsys a préféré, aux classiques banques d’images, des photographies de ses collaborateurs (crédits photos : Maria Mikulas). Ils sont ses meilleurs ambassadeurs !

Bonne visite sur www.netapsys.fr !

L’entretien annuel chez Netapsys

Marine Hamon — Mon, 26 Jan 2009 09:47:00 +0100

Chez Netapsys, nous partons du principe que c’est avant tout par envie que l’on réussit. Chacun est acteur de son évolution et construit son poste en fonction de ses motivations. L’entretien annuel permet d’avoir un échange privilégié avec son manager, la responsable RH et la direction.

Il se déroule en trois temps :

- Un premier entretien avec son chef de projet et la responsable RH. A cette occasion, nous faisons un bilan de l’année précédente en commençant par évaluer les compétences. Les critères sont définis au préalable afin de garantir l’objectivité des évaluations. Dès cette étape, le collaborateur est impliqué : il prépare une auto-évaluation ce qui lui permet de prendre du recul, d’identifier les forces sur lesquelles s’appuyer ainsi que les axes à améliorer. C’est en affinant ses auto-évaluations et en se corrigeant naturellement que l’on progresse le plus vite ! Par la suite, l'échange se poursuit à partir de l'évaluation du manager et de la responsable RH qui apportent leur regard extérieur et exposent leurs évaluations à partir d’éléments factuels. Nous évaluons également l’atteinte des objectifs et calculons le montant du variable sur objectif qui sera versé fin janvier.

- En deuxième partie de ces entretiens, nous abordons les éléments de motivation du collaborateur et définissons une projection. Cela permet de donner de la visibilité sur l’évolution de carrière, d’identifier la cible à un an et de décliner les objectifs pour l’année à venir. Le cadre fixé est volontairement souple afin de permettre à chacun d’apporter, durant toute l’année, sa valeur ajoutée sur les sujets qui l’intéressent le plus et ainsi de contribuer à la construction d’une entreprise qui favorise l’émergence d’idées nouvelles.

- Suite à ce premier entretien, un deuxième entretien est fixé avec Yoann Hébert afin d’entériner les orientations pour l’année à venir, de répondre aux éventuelles questions des collaborateurs et de pouvoir échanger sur la stratégie et l’évolution de Netapsys.

Netapsys est une entreprise en évolution permanente. Chacun grandit avec l’entreprise qui elle-même se construit grâce à l’apport de chaque Netapsyen.

Petits Déjeuners Netapsys / Intégration continue et outils de pilotage stratégique de vos projets

Sébastien Roul — Fri, 10 Oct 2008 16:22:00 +0200

Jeudi 20 novembre à Nantes, Netapsys Atlantique vous invite à son petit déjeuner technique : Intégration continue et outils de pilotage stratégique de vos projets.

Animée par Jean-Baptiste Defard, Directeur Technique Netapsys, cette présentation sera l'occasion de détailler l'apport de tels outils par rapport à vos problématiques d'industrialisation des développements, de qualité et de pilotage stratégique de vos projets.

Nous vous proposerons sur cette rencontre de répondre aux questions suivantes :

Qu'est-ce que l'intégration continue ?
Quelles sont les étapes importantes de sa mise en oeuvre ?
Quels sont les impacts au quotidien ?
Quels sont les outils disponibles ? Maven, Hudson, Sonar...
Quels retours d'expérience après plus d'un an d'utilisation ?

Inscription sur notre site : http://petitdejeuner.netapsys.fr

Séminaire Netapsys, un concept innovant de piraterie informatique…

Marine Hamon — Fri, 26 Sep 2008 17:54:00 +0200

Les 12 et 13 septembre, l’équipe Netapsys s’est réunie à Nantes afin de permettre aux collaborateurs parisiens de découvrir notre nouvelle agence, d’échanger sur les pratiques mais surtout de partager ensemble des moments de détente et de convivialité.

Après une visite des locaux, les collaborateurs soucieux de challenger l’animateur de la réunion prévue dans l’après-midi, ont fait honneur au déjeuner ! Par bonheur, Sébastien Roul avait concocté une séance de travail dynamique en s’appuyant sur des méthodes plus fréquemment utilisées en improvisation théâtrale qu’en entreprise. Et le résultat est là : 30 idées à la fois concrètes et créatives ont été proposées par les équipes !

Pour terminer la journée, les collaborateurs se sont retrouvés autour d’une table mais cette fois-ci pour un tournoi de poker. Nos nouvelles recrues, Pierre-Yves, Marc-Olivier et Florence, ont révélé des talents jusqu’alors cachés.

Quant au samedi, Bénédicte est parvenue à préserver la surprise jusqu’au bout malgré les pièges tendus par les plus curieux. C’est à bord de voiliers que les équipages ont découvert les berges de l’Erdre. Et là, point de piratage informatique… juste de la piraterie !

Photos de Darko Stankovski, Marc-Olivier Croix, Sébastien Hébert et Vincent Durand.

Un grand merci à toute l’équipe grâce à qui l’aventure Netapsys est possible et tout particulièrement à Yoann, Jérémy, Sébastien et Bénédicte pour l’organisation de ces deux journées.

Netapsys sur le JDN Développeurs - Intéropérabilité entre Java et .NET : rêve ou réalité ?

Sébastien Hébert — Mon, 01 Sep 2008 11:39:00 +0200

Netapsys publie un nouvel article sur le Journal du Net dressant une synthèse sur l'interopérabilité entre Java et .NET via les Services Web.

Si le sujet n'est pas nouveau en soi, quelques progrès sont à noter à savoir une meilleure prise en charge de la sécurité (authentification par certificat, etc.) et de la gestion transactionnelle. Les outils/technos dont il est question sont WCF 3.0 (Windows Communication Foundation apparu avec .NET 3.0) et Metro (piles de services Web) disponible dans Glassfish et utilisable sous Tomcat (implémentation à base de servlet disponible uniquement).

PS : Un grand merci à Yoann, Jérémy et Jean-Baptiste pour leurs retours.

Karting : championnat Netapsys / INDOM à Magny-cours

Yoann Hébert — Tue, 22 Apr 2008 13:39:00 +0200

Les as du volant ont encore frappé ! Ce n'est pas la première fois que l'équipe Netapsys se retrouve sur une piste de kart mais ce samedi 19 avril restera particulièrement mémorable. Il s'agissait tout simplement du premier championnat de karting Netapsys / INDOM sur le circuit mythique de Magny-Cours. Après une épreuve de qualification, qui a eu lieu à Paris et qui a permis de sélectionner les 5 meilleurs de chaque société, les deux équipes se sont retrouvées à Magny-Cours pour une journée bien remplie : visite d'une école de F1, accès aux stands du championnat Peugeot Sport, séance de karting sur le circuit dédié de Magny-cours...

Ci-joint le récit de cette journée par Stéphane Van Gelder, Directeur Général INDOM.

Opération Karting : Fair-play et parfaite égalité

Le 19 avril dernier, deux équipes avaient rendez-vous sur la piste karting du complexe automobile de Magny-Cours. D'un côté, les 5 qualifiés INDOM. De l'autre, le même nombre de pilotes pour représenter Netapsys. Tout ce petit monde arrive dès le matin sur la piste principale, celle du Grand Prix de F1. Certains sont visiblement déjà très chauds, au point de devoir abandonner quelques points sur leur permis avant même d'arriver au circuit…

Puisqu'il est question de F1, la journée commence par une visite guidée des ateliers LRS, spécialisée dans les stages de pilotage sur F1.

Le guide : Mathieu Zangarelli, l'un des meilleurs pilotes français. Dans les grands ateliers, on découvre les nombreuses F1 exploitées par LRS. On regarde, on touche, on prend même place à bord pour un voyage inoubliable dans les hautes sphères du sport automobile.

Mais déjà la tension monte. C'est l'heure de la course.
Une première séance d'essais libres permet à NETAPSYS de renforcer ses rangs, Yoann ne résistant pas à l'appel de la piste. INDOM domine néanmoins les essais puisque Patrick s'impose devant Vincent, Yoann et Nicolas. La tendance s'inverse en pré-finale, Vincent gagne cette course de 10 tours devant Patrick, Yoann et Mickael. Pour la grande finale de 15 tours, les plus rapides partent du fond de la grille. Patrick parvient néanmoins à s'extraire de la meute et va s'imposer. Suivent Yoann et Nicolas sur le podium final, puis Mickael, Vincent, Joachim, Romuald, Julie, Jeremy, Kefah et Brahim.

Au moment d'additionner les points, on ne pouvait rêver meilleur résultat puisque c'est l'équilibre parfait : chaque équipe marque 39 points… et tout le monde monte sur le podium !