Affichage des articles dont le libellé est java. Afficher tous les articles
Affichage des articles dont le libellé est java. Afficher tous les articles

vendredi 6 juillet 2012

Injecter un logger dans les spring beans

L'utilisation d'un logger est très importante dans tout projet, pour ma part j'utilise la bibliothèque LogBack (j'expliquerais dans un autre billet en détail les raisons qui m'ont motivé a le choisir).
Il nous faut donc une instance du logger dans chaque classe comme dans le code suivant :
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class UserService {
  
  private static Logger log = LoggerFactory.getLogger(UserService.class);
  
  public void create(String nom) {
        logger.debug("User with name " + args + " is created");
  }
}

Il serait interessant de pouvoir injecter une instance du logger avec Spring en utilisant les annotations.
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.FIELD)  
@Documented
public @interface Log {
    
}
Puis on définit un Spring bean processor
import java.lang.reflect.Field;
import org.slf4j.Logger;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.ReflectionUtils.FieldCallback;

import org.slf4j.LoggerFactory;

public class LoggerInjector implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException {
        ReflectionUtils.doWithFields(bean.getClass(), new FieldCallback() {

            @Override
            public void doWith(Field field) throws IllegalArgumentException,
                    IllegalAccessException {
                 
                ReflectionUtils.makeAccessible(field);
                if (field.getAnnotation(Log.class) != null) {
                    Logger log = LoggerFactory.getLogger(bean.getClass());
                    field.set(bean, log);
                }
            }
        });
        return bean;
    }
}

Ansi nous pouvons injecter un logger en utilisant l'annotation @Log
@Service
public class UserService {
  
   @Log
   Logger log;
  
  public void create(String nom) {
        log.debug("User with name " + args + " is created");
  }
}

Dans le fichier de configuration de Spring nous activons le component-scan en replaçant "le_nom_du_package" par le nom du package ou sont définie les Spring beans (par exemple : com.monapp )
 

<context:component-scan base-package="le_nom_du_package"/>

vendredi 29 juin 2012

Java enum et sa valeur entière

Il m'arrive d'utiliser les enum en java pour décrire une propriété (attribut) surtout dans le cas ou la valeur est une liste exhaustive.
Par exemple une énumération qui représente les unités de mesure :
public enum UniteEnum {
  PIXEL, CENTIMETRE, MILLIMETRE, POUCE
}

Cette énumération peut être utilisé comme attribut dans la classe suivante :
public class Longeur {
    private UniteEnum unite;
    private int valeur;
}
Pour persister la classe Longeur dans une base de donnée relationnelle on la fait correspondre à une table
create table longeur (
  valeur number(10),
  unite number(1)
);
Le type de la colonne unité est un nombre et non pas un String, il est plus simple de gérer une énumération en faisons correspondre sa valeur à un nombre qu'à une chaîne de caractère. Malheureusement dans le langage Java ce cas n'est pas géré, il faut alors ajouter quelques modifications dans UniteEnum pour simplifier la conversion depuis l'enum vers le nombre et inversement.
On ajoute un attribut qui représente la valeur entière de chaque enum et on définie un constructeur qui prend cette valeur comme paramètre
public enum UniteEnum {
    
    PIXEL(0),
    CENTIMETRE(1),
    MILLIMETRE(2),
    POUCE(3);

    private int intValue;

    UniteEnum(int intValue) {
        this.intValue = intValue;
    }
}
Il nous faut maintenant deux méthodes, une pour avoir la valeur entière d'un enum et une autre qui retourne un enum depuis sa valeur entière.

    public int value(){
        return this.intValue;
    }

    public static UniteEnum fromValue(int value){
       UniteEnum[] enums = UniteEnum.values();
        for (UniteEnum anEnum : enums) {
            if (anEnum.value() == value)
                return anEnum;
        }
        return null;
   }

On peut optimiser ce code surtout dans la méthode fromValue à la ligne 6

 UniteEnum[] enums = UniteEnum.values();

si cette ligne est appeler plusieurs fois on risque d'avoir des problèmes de performance, il serait mieux de la faire sortir dans une variable statique, pour avoir finalement ce code :
public enum UniteEnum {

    PIXEL(0),
    CENTIMETRE(1),
    MILLIMETRE(2),
    POUCE(3);

    private final static UniteEnum[] enums = UniteEnum.values();
    private int intValue;

    UniteEnum(int intValue) {
        this.intValue = intValue;
    }

    public int value(){
        return this.intValue;
    }

    public static UniteEnum fromValue(int value){
        for (UniteEnum anEnum : enums) {
            if (anEnum.value() == value)
                return anEnum;
        }
        return null;
    }
}
On exécute le test suivant en utilisant junit pour vérifier la conversion
public class UniteEnumTest {

    @Test
    public void testGetFromInt() {
        assertEquals(UniteEnum.PIXEL, UniteEnum.fromValue(0));
        assertEquals(UniteEnum.CENTIMETRE, UniteEnum.fromValue(1));
        assertEquals(UniteEnum.POUCE, UniteEnum.fromValue(3));

        assertNull("Aucune unité avec cette valeur", UniteEnum.fromValue(50));

        assertEquals(0, UniteEnum.PIXEL.value());
        assertEquals(1, UniteEnum.CENTIMETRE.value());
        assertEquals(3, UniteEnum.POUCE.value());
    }
}

mercredi 23 décembre 2009

Java EE 6 and GlassFish v3 Virtual Conference

La conférence virtuelle sur la nouvelle spécification JEE 6 et GlassFish V3 sortie la semaine dernière en deux version Full et Web Profile est désormais disponible en replay
Il faut disposer d'un compte Sun Online.

J'ai bien aimer la présentation de Linda DeMichiel la "Specification Lead" pour Java Persistence 2.0 JSR 317 et surtout la Criteria API qui existe depuis quelques temps dans le Framework Hibernate qui est devenu maintenant un standard, un exemple que j'ai trouvé interessant montre comment en utilisant cette nouveauté on peut faire des requetes typeSafe avec l'object CriteriaQuery.

dimanche 4 novembre 2007

La nouvelle page web de Netbeans Platform

Une nouvelle page sur le site de Netbeans a propos de sa plateforme basée sur le Rich Client Application Developpement a été ajoute dernièrement. Sur ce site on trouvera d'innombrables tutoriels, des documents et des informations très importantes. Incontournable pour ceux qui veulent maitrisé cette plateforme qui devient de plus en plus populaire, alors sans attendre prenez vos claviers et souris et... go!

mardi 23 octobre 2007

10 raccourcis pratiques dans l'éditeur de NetBeans IDE 6.0

Je vais vous présenté quelques raccourcis que je trouve incontournable de l'éditeur de code dans le célèbre NetBeans IDE 6.0 .

1- Déplacer copier haut / bas:
Ctrl-Shift-Haut le code sélectionner est déplacer vers le haut.
Ctrl-Shift-Bas le code sélectionner est déplacer vers le bas.
Ctrl-Alt-Haut le code sélectionner est copier vers le bas.
Ctrl-Alt-Bas le code sélectionner est copier vers le bas.

2- Sélectionner un bloc de code:
Shift-Alt-Point pour sélectionner un bloc de texte.

3- Générer des squelettes de code:
Alt-Insert pour afficher un petit menu ou on peut sélectionner les squelettes de setter et getter ou le constructeur.

4- Renommer :
Ctrl-R pour renommer une variable dans tout le sources code.

5- Ajouter enlever des commentaire:
Ctrl-/ la première foi pour ajouter les "//" au début de la ligne et une autre foi pour les enlever.

6- Afficher la hiérarchie
et les membres d'une classe:
Alt-F12 pour voir les ancêtres de la classe.
Ctrl-F12 pour afficher les membres de la classe.

7- Naviguer entre les documents:
Ctrl-Tab fait apparaitre un petit menu qui contient tous les documents ouverts dans l'éditeur et permet donc de choisir le document a afficher.

8- Aller a la dernière édition effectuée:
Ctrl-Q quelque soit l'emplacement actuel du curseur dans l'éditeur de code cette combinaison vous permet de revenir a l'emplacement exact de la dernière modification.

9- Bookmarks:
Ctrl-Shift-M la ligne courante est bookmarker.
Ctrl-Shift-Point et Ctrl-Shift-Virgule pour aller au bookmark suivant et précédant.

10- Mettre en surbrillance les points de sortie:
Il suffie de mettre le curseur sur le type retourner par la methode que tout les points de sortie sont automatiquement mis en surbrillance.

Bien sur c'est pas tout, Netbeans offre bien plus, mais puisque c'est impossible de tout citer je vous offre ce pdf qui contient presque tout les raccourcis clavier, et si vous avez d'autre raccourcis a nous faire découvrir j'attends vos commentaires avec impatience.

lundi 22 octobre 2007

Enfin mon premier projet communautaire voie le jour!

Bon soir, décidément aujourd'hui est une journée très animée. enfin notre projet d'application GsCommande a été hébergé avec succès sur les fameux serveurs de java.net sur cette adresse https://gscommande.dev.java.net/. Ce projet est née d'une initiative de wincom et moi, pour pouvoir appliquer nos connaissances de Uml et Java sur un projet d'application. Le but Gestion des commandes (GsCommande) est de bien sur gérer les commandes clients avec une interface Swing et une couche de persistance servie par le framework Hibernate.
En tant qu' administrateur de ce projet je tient a féliciter toute l'équipe en espérant une bonne continuation et j'invite bien sur tout le monde a intégrer notre équipe et d' y contribuer.

En fin je tient aussi a féliciter mon ami djo qui a fait surface après un très long silence a travers son blog qui est dédier a java et que je conseille fortement de le visiter a partir de ce lien