Exile on Keyboard St. - Blog sur Linux et Debian

Aller au contenu | Aller au menu | Aller à la recherche

lundi 6 août 2018

Java: Bien utiliser le Builder pattern

Quand on maintient du code Java, on tombe malheureusement assez souvent sur des méthodes aux signatures complexes comme celle-ci:

public int myMethod(String id, String name, Boolean secure, Object obj, Object backupObj, boolean restart)

Et il n'est pas rare d'avoir encore plus de paramètres !

La situation se dégrade encore quand pour "simplifier", on surcharge la méthode précédente en:

public int myMethod(String id, String name, Boolean secure, Object obj, Object backupObj)

quand restart vaut false puis en:

public int myMethod(String id, String name, Boolean secure, Object obj)

quand en plus backupObj est null.

On peut avoir ainsi 3 à 5 signatures différentes pour la même méthode. Et cela devient vite unsupportable quand on veut refactorer ces méthodes, parce qu'elles sont référencées n fois dans le code de production et également dans les tests.

Si le développeur qui a créé la première méthode avait créé un object et l'avait passé en paramètre de sa méthode, on n'en serait pas là !

Imaginons maintenant la méthode suivante qui permet de créer un utilisateur:

public long create(final String firstName, final String name, final int age)

Elle retourne l'identifiant de l'utilisateur créé. Supposons que l'age n'est pas obligatoire et que l'on souhaite anticiper l'ajout de nouveaux champs pour créer un utilisateur.

On va alors plutôt procéder comme suit:

public long create(final User user)

La classe User commencera comme ceci:

public class User
{
    private long id;
    private String firstName;
    private String lastName;
    private int age;
}

Mais pour créer un utilisateur à passer en paramètre de la méthode create, on va créer un Builder pour construire l'objet User.

Pour cela, on peut installer le Plugin Builder Generator. Un autre plugin est également disponible: Inner Builder.

Après redémarrage d'IDEA, un clic-droit puis Generate propose maintenant l'option "Builder" et on a alors la boite de dialogue suivante:

Capture-CreateBuilder.png

Ici on a choisi un "innerBuilder" afin que le Builder soit une classe interne de l'objet lui même.

On choisit ensuite la liste des champs à inclure, on ne prends pas l'id puisqu'il ne sera pas calculé par l'appelant de la méthode create mais bien par celle-ci:

Capture-Select_Fields_to_Be_Available_in_Builder.png

Et on obtient:


    public static final class UserBuilder
    {
        private String firstName;
        private String lastName;
        private int age;

        private UserBuilder()
        {
        }

        public static UserBuilder anUser()
        {
            return new UserBuilder();
        }

        public UserBuilder withFirstName(String firstName)
        {
            this.firstName = firstName;
            return this;
        }

        public UserBuilder withLastName(String lastName)
        {
            this.lastName = lastName;
            return this;
        }

        public UserBuilder withAge(int age)
        {
            this.age = age;
            return this;
        }

        public User build()
        {
            User user = new User();
            user.lastName = this.lastName;
            user.age = this.age;
            user.firstName = this.firstName;
            return user;
        }
    }

On crée ensuite notre User comme suit:

        final User user = UserBuilder
                    .anUser()
                    .withFirstName("Brian")
                    .withLastName("Kernighan")
                    .build();

Cette façon de faire permet:

  • de faire évoluer l'objet User en changeant un minimum de code
  • de valider les différents champs dans la méthode build

Et les signatures des méthodes ne changent pas.

On peut même éviter de dupliquer les champs de la classe User dans la classe UserBuilder en procédant comme ceci:

public static final class UserBuilder
    {
        private User user;

        private UserBuilder()
        {
            user = new User();
        }

        public static UserBuilder anUser()
        {
            return new UserBuilder();
        }

        public UserBuilder withFirstName(String firstName)
        {
            this.user.firstName = firstName;
            return this;
        }

        public UserBuilder withLastName(String lastName)
        {
            this.user.lastName = lastName;
            return this;
        }

        public UserBuilder withAge(int age)
        {
            this.user.age = age;
            return this;
        }

        public User build()
        {
            return user;
        }
    }

Mais notre générateur ne sait pas le faire :-(

samedi 2 juin 2018

Chercher dans des fichiers de log avec lnav

Quand on développe, on passe beaucoup de temps à consulter et à chercher des informations dans les fichiers de logs des produits ou du système.

J'ai longtemps utilisé glogg et maintenant il me parait lourd et peu efficace.

lnav que je vais vous présenter maintenant est plus léger et s'avère très performant grâce à de nombreux raccourcis clavier.

Au lancement, on obtient le résultat suivant:

lnav.png

Vous constatez qu'on est au début du fichier. Pour naviguer dans le fichier, on peut utiliser:

  • g pour aller au début
  • G pour aller à la fin
  • Page up ou Backspace/ Page down ou Espace pour naviguer de page en page

Mais ce qu'il y a de commode, c'est que lnav permet d'aller à la prochaine erreur, en tappant 'e' ou au prochain warning en tappant 'w'.

De la même façon, 'E' vous positionne sur l'erreur précédente et 'W' sur le warning précédent.

On peut également naviguer dans le temps, c'est à dire que la touche 'o' vous fait avancer de 24h dans le fichier et 'O' le fait dans le sens inverse. Si l'intervalle recherché est de 24h, il faut utiliser respectivement 'd' ou 'D'.

lnav vous autorise aussi à rechercher un motif en tappant /<regexp>, les regular expressions acceptées étant les PCRE (Perl-Compatible Regular Expressions).

Autre fonctionnalité intéressante, on peut marquer une ligne pour la retrouver plus tard avec la touche 'm'. Ensuite l'appui sur les touches 'u' et 'U' permet de naviguer d'une ligne marquée à l'autre. C'est très utile pour débugger.

Bref, lnav devient rapidement un outil indispensable du quotidien du développeur, et le fait qu'il soit utilisable directement dans un terminal est un atout non négligeable.

Je n'ai évidemment pas décrit ici tout ce qu'on faire avec, pour découvrir d'autres fonctionnalités, vous pouvez utiliser la touche '?' au démarrage de lnav.

dimanche 15 avril 2018

Rechercher rapidement dans le code source avec ack

Rechercher dans du code source est une des activités principales du développeur.

Dans les logiciels aux architectures incertaines et maintenant avec la "méthode" Agile, il est souvent diffcile de savoir rapidement ou est gérée telle ou telle fonctionnalité dans le code.

Pendant longtemps, rechecher dans le code ressemblait à ça:

find . -name "*.java" -exec grep HashMap {} \; -print

Certains me diront:

Bahhhhh, Qu'est-ce que c'est compliqué ?

Où encore l'excuse qui n'en est pas une:

Mais moi je suis sous Windows ...

Heureusement, il existe maintenant des outils plus rapides à l'usage que les commandes find et grep combinées.

J'ai découvert il y a quelques années la commande ack-grep ou ack qui est précisément faites pour notre besoin: chercher des motifs dans une base de code.

Je vous passe ici l'installation d'ack: ack est un script Perl qui s'installe très simplement ; évitez le package de votre distribution afin d'avoir la version la plus récente.

Maintenant, notre commande précédente s'écrit comme suit:

ack --java HashMap

C'est quand même plus court !

J'ai précisé à la commande que je voulais chercher dans des sources Java. Dans types de fichiers sont prédéfinis dans ack:

 ack --help-types
Usage: ack [OPTION]... PATTERN [FILES OR DIRECTORIES]

The following is the list of filetypes supported by ack.  You can
specify a file type with the --type=TYPE format, or the --TYPE
format.  For example, both --type=perl and --perl work.

Note that some extensions may appear in multiple types.  For example,
.pod files are both Perl and Parrot.

    --[no]actionscript .as .mxml
    --[no]ada          .ada .adb .ads
    --[no]asm          .asm .s
    --[no]asp          .asp
    --[no]aspx         .master .ascx .asmx .aspx .svc
    --[no]batch        .bat .cmd
    --[no]cc           .c .h .xs
    --[no]cfmx         .cfc .cfm .cfml
    --[no]clojure      .clj
    --[no]cmake        CMakeLists.txt; .cmake

Si vous utilisez un type de fichier non connu d'ack, vous pouvez le définir.

Ensuite, de nombreuses options de la commandes ack sont reprises de celles de grep:

       -i, --ignore-case
           Ignore case distinctions in PATTERN
       -v, --invert-match
           Invert match: select non-matching lines

ou les classiques:

       -l, --files-with-matches
           Only print the filenames of matching files, instead of the matching text.

       -L, --files-without-matches
           Only print the filenames of files that do NOT match.

ack permet comme grep d'afficher les lignes de contexte autour du motif trouvé:

       -A NUM, --after-context=NUM
           Print NUM lines of trailing context after matching lines.

       -B NUM, --before-context=NUM
           Print NUM lines of leading context before matching lines.

ce qui facilite la lisibilité de la sortie.

Par défaut, ack va parcourir tous les sous-répertoires du répertoire courant. Ce comportement peut-être changé par:

       -r, -R, --recurse
           Recurse into sub-directories. This is the default and just here for compatibility with grep. You can also use it for
           turning --no-recurse off.

Enfin, ack peut utiliser un fichier de configuration ~/.ackrc.

Pour créer celui utilisant les options par défaut:

ack --create-ackrc > ~/.ackrc

- page 1 de 4