MyTekLog http://blog.konkest.com Carnet de notes techniques... Mon, 20 Jul 2009 13:26:15 +0000 http://wordpress.org/?v=2.8.2 en hourly 1 NetBeans 6.7 mais où sont les librairies ? http://blog.konkest.com/?p=136 http://blog.konkest.com/?p=136#comments Mon, 20 Jul 2009 13:26:15 +0000 admin http://blog.konkest.com/?p=136 L’autre jour j’ai installé NetBeans 6.7 pour pouvoir tester les nouveautés et me refamiliariser avec cet environnement que j’avais pas mal délaissé pour Eclipse.


Je décide alors de suivre quelques tutoriaux pour me faire la main et appréhender la bête.
Et voilà que je me retrouve en quelques minutes bloqué avant même la première ligne de code ! Ces satanés tutoriaux parlent de menus contextuels de configuration que je n’ai pas ! Notamment au niveau des librairies.


Comment cela se fait-il ? Comment y rémédier ?



Library Manager vide !

Première constatation étrange :

Je vais dans Tools > Libraries pour ouvrir le « Library Manager » et la … RIEN !
Cela est très déroutant !

La solution n’est pas bien compliquée:

Il suffit donc de créer un nouveau projet Java par exemple : File > New Project > Java > Java Application
et zou… tout apparait, allez comprendre ?



Maintenant a quoi est ce du ? Un soucis d’optimisation ? On ne charge les données que si un projet est créé ? Bref pas sorcier mais bizarre.


Libraries Javascript (JQuery, MooTools et autres)

Toujours a me battre avec mes tutoriaux et mes bibliothèques, je cherchais désespérément à ajouter par exemple la complétion automatique pour du JQuery.
Je trouve donc des indications pour le faire : Click droit sur le projet puis choisir « Properties » et enfin sélectionner « Javascript Libraries« .

Voir le tuto suivant en anglais : Using jQuery … on NetBeans


Et bien que néni, point de menu « Javascript Libraries » sur les propriétés de mon projet !
Imaginez donc ma frustration !

Mais la solution est la encore toute simple !

Il suffit d’ajouter le jquery.js dans un des répertoires source de votre projet et de l’inclure dans votre page courante.
La NetBeans parse le fichier, et gère automatiquement la complétion de code, magique non ? Encore fallait il le savoir et faire le test avant de perdre quelques 10aines de précieuses minutes a chercher comment faire.

]]> http://blog.konkest.com/?feed=rss2&p=136 2 JQuery et MooTools sans conflit http://blog.konkest.com/?p=126 http://blog.konkest.com/?p=126#comments Fri, 17 Jul 2009 15:35:56 +0000 admin http://blog.konkest.com/?p=126 Plutôt adepte de JQuery, je me retrouve parfois confronté à l’utilisation de JQuery et de MooTools simultanément.
Ceci posera a coup sur des problèmes si l’on n’y prend pas garde du fait des grandes similitudes de notations comme l’appel à la fonction $.

Il existe bien évidement un contournement de ce genre de problèmes que voici :

Tout d’abord il faut respecter l’ordre de déclaration des scripts :

  1. jquery.js
  2. Vos autres scripts JQuery
  3. mootools.js
  4. Vos autres scripts MooTools

Ensuite il faut dans la partie JQuery commencer par déclarer :

    jQuery.noConflict();

Puis penser à remplacer dans tous les scripts JQuery les appels $() par jQuery()

    // On remplace par exemple 
    //     $(document.body).css('background-color', 'lightblue'); 
    // par :
    jQuery(document.body).css('background-color', 'lightblue');

Voila si vous n’êtes pas certains d’avoir tout compris je vous propose un exemple super simple illustrant ce qu’il faut faire :

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Test JQuery et MooTools</title>
    </head>
    <body>
        <h1> Ceci est un test </h1>
        <!-- // DEBUT SCRIPTS JS -->
        <script language="Javascript" type="text/javascript" src="js/jquery.js"></script>
        <script language="Javascript" type="text/javascript">
            // JQuery
            jQuery.noConflict();
            jQuery(document.body).css('background-color', 'lightblue');
        </script>
        <!-- Déclarer MooTools et les scripts MooTools après JQuery et les scripts JQuery -->
        <script language="Javascript" type="text/javascript" src="js/mootools.js"></script>
        <script language="Javascript" type="text/javascript">
            // MooTools
            var bodyElement = $(document.body);
            bodyElement.setStyle('color', 'darkgreen');
        </script>
        <!-- // FIN SCRIPTS JS -->
    </body>
</html>
]]> http://blog.konkest.com/?feed=rss2&p=126 4 IDE PHP lequel chosir ? http://blog.konkest.com/?p=123 http://blog.konkest.com/?p=123#comments Wed, 08 Jul 2009 08:33:58 +0000 finalspy http://blog.konkest.com/?p=123 Si comme moi vous vous êtes un jour dit que textpad, notepad ou autre éditeur de texte simple, bien que suffisant pour faire du php+html+css+js, n’est pas toujours hyper productif. J’entends pas la que ces outils manquent de fonctionnalités avancées, ou sont configurables mais difficilement et pas nativement, ou peu complets concernants les points suivants :

  • pas ou peu de complétion,
  • mise en forme limitée,
  • pas mis en évidence des erreurs de syntaxe…

Alors l’article suivant va vous éclairer sur la question : The big PHP IDE’s test – Why use one and which to choose ?

Traduction française en cours.

]]> http://blog.konkest.com/?feed=rss2&p=123 0 Un peu plus loin avec Wicket et Spring : Vive l’AOP ! http://blog.konkest.com/?p=73 http://blog.konkest.com/?p=73#comments Thu, 02 Jul 2009 21:32:02 +0000 admin http://blog.konkest.com/?p=73 Ceux qui connaissent un peu Spring et l’AOP sauront l’intérêt énorme de cette technique de programmation pourtant encore trop peu connue des développeurs (en tout cas de ceux que je croise).

Je vous propose ici de saupoudrer votre merveilleuse plateforme Eclipse Maven Wicket Spring avec une dose d’AOP histoire de devenir encore un peu plus performants !

L’article qui suit décrit comment ajouter un peu d’AOP sur un projet Wicket.
Pour prendre un exemple concret nous allons ajouter en AOP des traces vers la console rapportant l’utilisation de méthodes d’objets injectés et également leur temps d’exécution, sympa non ?

Pour bien commencer

Pré-requis

Avoir Eclipse (si possible Ganymède pour développeurs JavaEE).
Avoir le plugin Maven m2eclipse installé.
Avoir le plugin Subversion Subclipse installé.

Savoir créer un projet Maven avec l’archetype Wicket (version 1.3.6 pour cet exemple).

Et avoir lu l’article sur le couplage Wicket Spring (ou sur noocodecommit) serait un plus.
Savoir importer un projet SVN sous eclipse également.

Sources de départ

Les sources pour bien commencer sont disponibles sous SVN : http://blog.konkest.com/svn/WicketSpring (non ce n’est pas une erreur et bien les sources d’un précédent article sur lequel nous nous baserons pour la présente démonstration).

Rappel Couplage wicket Spring

1°) Modifier le pom.xml et rajouter d’une part les dépendances Spring :

<dependency>
	<groupId>org.apache.wicket</groupId>
	<artifactId>wicket-spring-annot</artifactId>
	<version>${wicket.version}</version>
</dependency>
<!--  SPRING DEPENDENCIES -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring</artifactId>
	<version>${spring.version}</version>
</dependency>

2°) et d’autre part la version des dépendances à utiliser :

<properties>
	<wicket.version>1.3.6</wicket.version>
	<jetty.version>6.1.4</jetty.version>
	<spring.version>2.5.4</spring.version>
</properties>

3°) Modification du niveau de compilateur en 1.5+ et des project facets en conséquence 5.0+
Pour cela il faut faire un click droit sur le projet puis « propriétés ».
Puis aller sur « Java Compiler » et changer le « Compiler compliance level » (désolé je bosse sous une version anglaise).
Change compiler level

Ensuite allez sur « Project Facets » et changez Java de 1.4 à 5.0 au moins, en cliquant sur « Modify project ».
Voici comment se présentent ces écrans :
Modify Project Facet
Choose Facets

4°) Ajout de la référence au fichier de configuration Spring dans web.xml

<!-- Déclaration du fichier externe de configuration de Spring -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springConfiguration.xml</param-value>
</context-param>

5°) Ajout du fichier springConfiguration.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns: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">
 	<!-- Indique à  Spring de scanner les package pour trouver les annotations en vue de l'injection -->
	<context:annotation-config/>
	<context:component-scan base-package="com.konkest"/> 
	<!-- Indique à Spring quelle classe Wicket doit être injectée en tant qu'application -->
	<bean id="wicketApplication" class="com.konkest.WicketSpring.WicketApplication">
	<bean>
</beans>

Attention cela ne suffit pas pour cet exemple puisqu’il vous faut ajouter des classes à injecter via Spring…
(cf. les sources SVN et l’article sur le couplage Wicket et Spring.)

Configuration …

Ici j’utilise l’AOP dans le cadre de Spring.
Pas forcément la meilleure utilisation de l’AOP, mais facile et rapide a mettre en oeuvre pour de petits besoins.

Ajout des dépendances Maven pour l’AOP

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aop</artifactId>
	<version>${spring.version}</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>${spring.version}</version>
</dependency>

Déclaration de l’AOP

Dans le springConfiguration.xml
Ajout des namespaces aop

xmlns:aop="http://www.springframework.org/schema/aop"

et dans la partie schemaLocation :

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

Ajout des déclarations de « jointpoint » et d’ »aspect »

Dans le springConfiguration.xml toujours :

<!--	Debut de la configuration AOP -->	
<aop:config>
	<aop:pointcut id="pagePointcut"  expression="execution(* com.konkest.faune.*.*(..))"/>     		
	<aop:aspect id="testAspect" ref="myTimer">
	    <aop:before method="pageMethodEntry"  pointcut-ref="pagePointcut"/>    		
	    <aop:after method="pageMethodExit" pointcut-ref="pagePointcut"/>
    </aop:aspect>	    
</aop:config>

Attention notez bien que je définis le pointcut sur les méthodes des classes du package faune uniquement.
Cela est fait volontairement car Spring ne peut bien évidement travailler en AOP que sur des choses qu’il connait, donc des classes qui lui ont été déclarées comme par exemple Chien et/ou Chat via l’injection de dépendances.
Par ailleurs si vous tentez de mettre : 

expression="execution(* com.konkest..*(..))"

(qui défini le pointcut sur l’exécution de toutes les méthodes de toutes les classes du package com.konkest et de ses sous-packages)
Vous constaterez que rien de plus n’apparait dans notre exemple. Forcément Spring ne connait rien d’autre dans le cas présent.

Déclaration du Bean de l’aspect

Dans le springConfiguration.xml encore :
Ajout de la déclaration du bean référencé par pageCallCounter qui contient l’aspect et ses méthodes

<bean id="myTimer" class="com.konkest.aspect.MethodeTimer"/>

Notre aspect de test

Pour cet exemple simpliste nous allons juste tracer le temps d’exécution d’une méthode.
Cela montre quand meme l’utilité de l’AOP pour ajouter des traces applicatives après coup, ou pour tenter par exemple de débusquer les point faibles d’une application en termes de performance.
Voici le code de notre aspect de test « MethodeTimer », à placer dans le package « com.konkest.aspect »

package com.konkest.aspect;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.JoinPoint.StaticPart;
 
public class MethodTimer {
	  private long start;
	  private long duration;
 
	  // Cette méthode est appelée à chaque fois (et avant) qu'une méthode du package défini dans le pointcut est interceptée 
	  public void pageMethodEntry(JoinPoint joinPoint) {
		 // Nom de la méthode interceptée
		 String name = joinPoint.getSignature().toLongString();
		 System.out.println("### Start : " + name);
		 start = System.currentTimeMillis();
	  }
 
	  // Cette méthode est appelée à chaque fois (et après) qu'une méthode du package défini dans le pointcut est interceptée 
	  public void pageMethodExit(StaticPart staticPart) {
		 duration = System.currentTimeMillis() - start;
		 // Nom de la méthode interceptée
		 String name = staticPart.getSignature().toLongString();
		 System.out.println("### End of " + name + " after " + duration + " ms.");
	  }
}

Test de notre aspect (non ce n’est pas du verlan ^^)

Et bien il faut exécuter notre projet sur le serveur Tomcat… (clique droit sur le Projet, Run As > Run on server)

Et voici si tout va bien le résultat :

Console :

Vue console montrant des traces générées par AOP.

Sources du présent article

Les sources de cet article sont disponibles sous SVN : http://blog.konkest.com/svn/WicketAOPSpring.

Conclusions

Nous venons de voir que nous pouvons aisément utiliser Spring pour faire outre l’injection de dépendance, de la programmation orientée aspect, le tout sur notre application Wicket. Elle est pas belle la vie ?

Seules remarques négatives, à ma connaissance et du fait du mécanisme interne de Spring AOP par création automatique de proxy au chargement, l’utilisation de l’AOP est limitée uniquement sur l’exécution des méthodes des classes injectées. Et également de possibles problèmes de performance (je n’ai jamais utilisé l’AOP suffisamment en profondeur avec Spring ou un autre tisseur d’aspect pour en juger par moi-même).

C’est déjà pas mal mais on peut mieux faire … Affaire à suivre donc, par exemple avec AspectJ et le plugin AspectJDevelopmentTool (AJDT) sous Eclipse.

Ressources

Pour compléter cet article je vous propose de poursuivre la lecture sur les pages suivantes :

]]> http://blog.konkest.com/?feed=rss2&p=73 1 window.location – Changement de page JavaScript http://blog.konkest.com/?p=91 http://blog.konkest.com/?p=91#comments Fri, 05 Jun 2009 23:07:11 +0000 admin http://blog.konkest.com/?p=91 Encore un siouxerie JavaScript qui m’a fait m’arracher les cheveux qui me restent avant de trouver la solution.
Habitué par le passé, à coder en html/javascript, je me souvenais que l’on pouvait simuler un lien par du JavaScript en utilisant le code suivant par exemple :

    <span onclick="window.location='nouvellePage.htm'"> cliquez ici </span>

Sauf que voilà sur mes derniers tests cela ne fonctionne pas !

J’ai donc cherché et testé un paquet de méthodes pour arriver à mes fins.
Et j’ai fini par trouver la solution que je vous livre ci-dessous.

Solution

Il faut donc utiliser window.location.href, combiné à la méthode setTimeout() normalement utilisée pour retarder l’exécution d’une action javascript.

Ne me demandez pas le pourquoi ce ce mystère, mais cette méthode a le mérite de fonctionner sur les divers navigateurs testé dont :

  • Firefox 3.0
  • Internet Explorer 7
  • Chrome 2
  • Safari
  • Opera

L’explication que j’ai pu lire est que certains navigateurs n’effectueront pas le changement de page tant que la page en cours n’aura pas terminé son chargement.
Par ailleurs il semblerait (à vérifier) que window.location soit une ancienne forme qui ne devrais plus être utilisé, mais certains sites mentionne window.location.href comme une abbération microsoft ? Qui croire ? … toujours est il que parfois ca marche sans le href et parfois non… (et cela sur les meme navigateurs mais des machines différentes).

Si quelqu’un qui passe par la a une idée ou une explication, je prends.

Sinon, une chose intéressante est aussi d’externaliser le code ci-dessus pour le réutiliser à plusieurs endroits.
Mais attention il peut-être perturbant d’utiliser setTimeout et window.location.href dans une fonction javascript paramétrable du fait de la position des doubles et simple guillemets!

Voici donc un exemple correct :

    <script type="text/javascript">  
        function changePageSimple(newpage){ 
            // Attention a noter la position des " et ' très importante sinon cela ne marche pas. 
            setTimeout("window.location.href = '"+newpage+".php'" , 0 ); 
        } 
    </script>

suivi de …

    <li onclick="changePageSimple('nouvellePage');">cliquez ici</li>

Encore une fois j’espère avoir été utile à quelqu’un et que le temps que j’ai pu moi même passer à trouver la solution à ce problème ait été épargné à une autre personne.

]]> http://blog.konkest.com/?feed=rss2&p=91 0 Utiliser Spring pour l'injection de dépendances sous Wicket ! http://blog.konkest.com/?p=11 http://blog.konkest.com/?p=11#comments Sat, 23 May 2009 00:50:48 +0000 finalspy http://konkest.wordpress.com/?p=11 Cet article va vous présenter les quelques étapes nécessaires pour coupler Wicket avec Spring, histoire de bénéficier par exemple de l’injection de dépendances.

Pré-requis

Si vous avez tout suivi à la lettre, et que vous lancez l’application sur un serveur (Click droit sur le projet, Run As > Run on Server), vous devriez voir la page suivante dans un navigateur :

L’ajout de Spring

Ajout des dépendances dans Maven

Dans un premier temps nous allons ajouter une dépendance pour permettre l’intégration de Wicket et Spring.

Pour cela, dans le fichier pom.xml ajouter la dépendance suivante :

<dependency>
    <groupId>org.apache.wicket</groupId>
    <artifactId>wicket-spring-annot</artifactId>
    <version>${wicket.version}</version>
</dependency>

Si vous avez suivi le QuickStart sur Wicket et Maven vous devriez avoir la variable wicket.version définie en bas de fichier. Sinon pensez à la déclarer …

Ensuite il faut ajouter la déclaration de dépendance du package principal de Spring (pas l’unique mais ici ce sera suffisant).

<!--  SPRING DEPENDENCIES -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>${spring.version}</version>
</dependency>

La encore vous remarquerez l’utilisation d’une variable « spring.version » qu’il faut déclarer en fin de fichier en ajoutant par exemple :

<properties>
    <wicket.version>1.3.5</wicket.version>
    <jetty.version>6.1.4</jetty.version>
    <spring.version>2.5.4</spring.version>
 </properties>

Préparer l’application pour l’utilisation de Spring

Il faut modifier ensuite votre application Wicket pour y ajouter d’une part une méthode de récupération du contexte comme suit :

/**
 * Récupération du contexte applicatif
 * @return ApplicationContext
 */
public final ApplicationContext context() {
    return WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext() );
}

Puis ensuite toujours dans votre application modifier la méthode init() pour ajouter un écouteur d’instanciation de composant utilisant l’injection de dépendance de Spring.

protected void init() {
    super.init();
    // Permettre l'injection de dépendances par Spring
    addComponentInstantiationListener( new SpringComponentInjector( this, context() ) );
}

Pour vous éviter les galères si votre IDE negère pas la recherche automatique d’imports, voici donc les imports nécessaires :

import org.apache.wicket.spring.injection.annot.SpringComponentInjector;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

A ce stade si votre projet est en build automatique et que votre serveur détecte les changements et se relance, il y aura des erreurs car nous n’avons pas configuré Spring et son contexte applicatif.

Ajout d’un fichier de configuration pour Spring

Il faut modifier le fichier Web.xml et ajouter la déclaration du fichier de paramétrage spécifique de Spring, en début de fichier, après le display-name idéalement, de la façon suivante :

<!-- Déclaration du fichier externe de configuration de Spring -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springConfiguration.xml</param-value>
</context-param>

Il faut également rajouter la déclaration de listener suivant en fin de fichier web.xml, pour permettre l’utilisation de beans de portée request, session, global session. Attention le code qui suit est valable pour les conteneurs de servlets 2.4 et supèrieurs. (pour plus de détails sur la configuration Spring se reporter à la Documentation Spring – lien dans les ressources en bas de cet article).

<!-- Declaration du Listener de chargement de contexte de Spring -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Puis bien évidement il faut créer le fichier en question et le placer idéalement dans le répertoire src/main/resources.

Voici le contenu minimum du fichier :

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
                  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		  xmlns: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">
	<!-- Indique à Spring quelle classe Wicket doit être injectée en tant qu'application -->
	<bean id="wicketApplication" class="com.konkest.WicketSpring.WicketApplication">
	</bean>
</beans>

Pensez à remplacer « com.konkest.WicketSpring.WicketApplication » par le path complet de votre application package+classe.

A ce stade votre projet doit compiler et se lancer sur le serveur sans changement notable.

(Tout cela c’est bien beau mais si on en fait rien ça n’a pas d’intérêt.)

Testons un peu le couplage Spring/Wicket

Nous allons tester l’une des fonctionnalités la plus utilisée de Spring :  l’injection de dépendances.

Pour cela je vous propose de créer un exemple idiot constitué de :

  • une interface IAnimal proposant une méthode :
    • public String crier(); 
      public interface IAnimal {
    public String crier();
}
  • Et deux classes l’implémentant :
    • Chien qui retourne « Ouaf ouaf »
    • Chat qui retourne « Miaou miaou »
import org.springframework.stereotype.Component;
@Component( "chien" )
public class Chien implements IAnimal {
    public String crier() {
	return "ouaf ouaf";
    }
}

et

import org.springframework.stereotype.Component;
@Component("chat")
public class Chat implements IAnimal{
    public String crier() {
	return "miaou miaou";
    }
}

Et bien évidement nous allons utiliser tout cela dans notre HomePage Wicket en ne manipulant que l’interface, et injecter l’implémentation via Spring.

Injection par annotations

Première chose à faire pour permettre l’utilisation des annotations, il faut configurer votre projet Eclipse pour les supporter. Pour cela deux choses à faire :

  • Ajouter une compatibilité java 5.0 (Click droit sur le projet, puis Properties et Java Compiler, changer alors le compiler compliance level sur 5.0)

20090523_03_ChangeCompilerLevel

  • Changer le niveau de project facets (toujours dans les propriétés du projet, choisir Project Facets et vérifier que la version pour Java est à 5.0)

20090523_02_ChangeProjectFacet

Maintenant nous allons rajouter la déclaration de l’interface IAnimal dans la HomePage :

@SpringBean( name = "chien" )
private IAnimal animal;

Il faut alors importer :

import org.apache.wicket.spring.injection.annot.SpringBean;

ainsi que IAnimal si elle n’est pas dans le package de la HomePage.

import com.konkest.faune.IAnimal;

Puis pour le besoin du test on va appeler la méthode crier de l’interface IAnimal :

add(new Label("message", "Mon animal fait : " + animal.crier()));

en remplaçant le précédent Label généré automatiquement lors de la création du projet.

A ce stade le code compile et le serveur se lance mais l’application provoque une Unexpected Runtime Exception lorsque l’on y accède. En effet nous n’avons pas dit à Spring qu’il devait scanner les packages pour trouver les annotations et s’en servir pour l’injection des dépendances.

Dernière étape donc : indiquer à Spring qu’il doit scanner les packages et utiliser les annotations pour l’injection. Pour cela il faut modifier le fichier de configuration de Spring dans notre projet : springConfiguration.xml, et ne pas oublier de modifier les déclarations de namespaces.

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   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">
	<context:annotation-config/>
	<context:component-scan base-package="com.konkest.WicketSpring"/>

Et voilà il n’y a plus qu’a tester en lançant votre serveur… si tout va bien « ouaf ouaf » devrait apparaitre…

20090523_04_ouaf

Changez donc l’annotation en :

@SpringBean( name = "chat" )
private IAnimal animal;

et relancez … « miaou miaou » …

20090523_05_miaou

C’est un peu bof comme exemple mais ça prouve que l’injection via Spring fonctionne
:) Félicitations ! et merci pour la patience d’avoir suivi jusque là.

Prochaine étape Ajouter Hibernate … A suivre …

Sources disponibles sous SVN

Se connecter au repository suivant : http://blog.konkest.com/svn/WicketSpring .

Ressources utilisées pour cet article:

]]> http://blog.konkest.com/?feed=rss2&p=11 3 Nexus Indexer vide sous Eclipse avec plugin m2eclipse … http://blog.konkest.com/?p=45 http://blog.konkest.com/?p=45#comments Fri, 22 May 2009 14:14:23 +0000 finalspy http://konkest.wordpress.com/?p=45 Au moment de choisir l’archétype pour démarrer mon nouveau projet, je me rends compte que dans la liste de Nexus Indexer il n’y a rien ! Vide… Néant …

Après pas mal d’installations d’Eclipse Ganymède et du plugin m2eclipse pour lui adjoindre des facilités d’utilisation de Maven, je me suis retrouvé confronté ce matin même à cette étrangeté.

Habituellement pour démarrer un projet Wicket par exemple, je le démarre à partir d’un projet Maven en choisissant l’archetype qui va bien.
( Comme indiqué dans ce très bon tutorial sur NooCodeCommit, que je ne vais pas perdre de temps à recopier.)

Bref voila que je démarre mon projet, et au moment de choisir l’archétype, je me rends compte que dans la liste de Nexus Indexer il n’y a rien ! Vide… Néant …
legende

Je n’ai pas encore l’explication du pourquoi du comment cela a toujours fonctionné sauf dans mon installation de ce matin.

Cependant j’ai trouvé comment résoudre le problème.

Pour cela, allez sur Window > Show View > Other

legende

Puis choisir Maven > Maven Indexes

legende

Là j’ai effectivement constaté que je n’avais que le repository relatif a mon workspace et mon repository local dans mon .m2 :

legende

J’ai alors rajouté le repository central de maven : http://repo1.maven.org/maven2

legende

Il faut alors vérifier qu’il a bien été ajouté dans la vue « Maven Indexes »

legende

Enfin il ne reste ainsi plus qu’a retourner sous File > New > Project puis Maven > Maven Project et vérifier que sur l’écran de sélection des archetypes la liste est revenue pour le Nexus Indexer :

legende

J’espère que cela sera utile à quelqu’un, histoire que je sois le seul a y avoir perdu encore quelques cheveux ^^

]]> http://blog.konkest.com/?feed=rss2&p=45 2 NormandyJUG Première ! http://blog.konkest.com/?p=41 http://blog.konkest.com/?p=41#comments Tue, 19 May 2009 14:52:22 +0000 finalspy http://konkest.wordpress.com/?p=41 logo-juggy2 C’est officiel, la première réunion du NormandyJUG (Java User Group) se tiendra le Mardi 16 Juin à partir de 19h au pôle normand des échanges électronqiues.

Elle aura pour principal sujet la comparaison de deux des frameworks Web en technologie Java qui font le plus parler d’eux en ce moment :
Google Web Toolkit (GWT) face à Wicket !

Les contributeurs :

Youen Chéné (www.fermiersdacote.com)

Nicolas Giard (www.noocodecommit.com)

La deuxième partie sera consacrée à :
l’Intégration Continue

Contributeur :

Dimitri Baeli ( eXo Platform )

Plus d’infos sur :
www.normandyjug.org

]]> http://blog.konkest.com/?feed=rss2&p=41 0 Joomla! – Inclure du PHP personnalisé sans Wrapper ! http://blog.konkest.com/?p=30 http://blog.konkest.com/?p=30#comments Thu, 14 May 2009 13:52:58 +0000 finalspy http://konkest.wordpress.com/?p=30 Pour tous ceux qui comme moi veulent réutiliser dans Joomla! leurs scripts PHP existant, ou rajouter vite fait des fonctionnalités sans pour autant coder leurs propres modules/composants, il y a des solutions pour inclure facilement votre code PHP perso dans un composant, dans un menu ou même dans un article !

Voici la solution que j’ai testé aujourd’hui et qui me parait plutôt pas mal : 

Logo JUMI

Logo JUMI

Pour plus d’informations reportez vous soit :

Jumi permet 3 types d’inclusions :

  • Via un composant
  • A l’emplacement d’un module
  • Dans un article

L’avantage principale par rapport a l’utilisation d’un wrapper par exemple est que vos paramètres seront récupérables nativement dans votre code PHP.
Autre gros avantage, pas d’iframe au comportement aléatoire et incertain parfois sur les héritages de styles etc.
Par ailleurs dans le cas d’un composant, et d’un lien de menu pointant vers celui-ci, vous n’avez pas l’embêtement des URL absolues obligatoires.

Bref pour moi que du positif!
Je pense même que, sauf pour du contenu externe, l’utilisation des wrappers va disparaitre de mes sites Joomla!

]]> http://blog.konkest.com/?feed=rss2&p=30 1 CMS et moteurs de blogs où est la limite ? http://blog.konkest.com/?p=7 http://blog.konkest.com/?p=7#comments Wed, 13 May 2009 22:12:45 +0000 finalspy http://konkest.wordpress.com/?p=7 Je viens de lire un article et des commentaires intéressants sur l’utilisation de Wordpress en tant que CMS et le pourquoi du comment :

Wordpress comme CMS ?

A méditer … car on y lit le point de vue de développeurs mais aussi d’utilisateurs finaux (ici des journalistes).

Personnellement je serai tenté de dire : « et pourquoi pas ? ».
Franchement a l’utilisation les CMS ce n’est pas toujours hyper pratique quand même. Pour les développeurs c’est rapidement la galère quand on veut faire quelque chose de spécifique, et parfois c’est a se demander si un bon vieux site « from scratch » ne serait pas sur les rails plus vite.
Wordpress a l’avantage d’être plutôt simple côté prise en main, une énorme communauté anglophone, et pleins de possibilités niveau personnalisation du style.

Je serai curieux d’avoir vos opinions, et si vous vous êtes déjà posé la question de la limite entre blog et CMS, où la situeriez vous ? Qu’est ce qui justifie l’utilisation d’un CMS ? Et où un moteur de blog simple et performant est il plus approprié ?

La frontière ne me semble pas bien nette …

]]> http://blog.konkest.com/?feed=rss2&p=7 1