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 14 juillet 2018

Changer les serveurs DNS utilisés par la Freebox

J'ai (j'avais) souvent des problèmes de lenteur sur Internet avec la Freebox.

Après recherche, il s'est avéré que ce problème provenait du temps de réponse du serveur DNS.

Comme par défaut, le serveur DNS utilisé avec une Freebox est celui de la Freebox elle même, j'ai changé la valeur: 192.168.0.254, qui est l'adresse du boitier freebox server, avec les valeurs des serveurs DNS fournis par un fournisseur d'accès à Internet associatif, à savoir FDN.

Ces valeurs sont les suivantes:

  • 80.67.169.12
  • 80.67.169.40

Capture-Informations_sur_la_connexion.png

Et de cette façon, je n'ai plus de soucis avec mes requêtes DNS !

Serveurs DNS de FDN

dimanche 24 juin 2018

Ecouter la radio sous Linux avec Radiotray

C'est bien agréable d'écouter un peu de musique quand on travaille, pour peu qu'on n'ait pas besoin d'être très concentré pour accomplir notre tâche en cours.

Sous Linux, l'application Radiotray permet d'écouter très simplement les radios qui diffusent un flux mp3 sur Internet.

De nombreuses radios sont préconfigurées mais les stations Françaises n'y figurent pas.

Aussi, j'ai commencé par ajouté les radios principales de Radio France:

  • France Inter
  • France Info
  • France Culture
  • France Musique

Mais ce qu'il y a de bien avec les flux MP3, c'est que le choix est plus important qu'en FM. Par exemple, pour la musique, Radio France nous propose entre autres:

  • France Musique | Classique Easy
  • France Musique | Classique Plus
  • France Musique | Concerts Radio France
  • France Musique | La Jazz

La dernière permettant de remplacer allègrement TSF, qui est une très bonne radio, mais passe désormais tellement de publicité qu'il n'est plus possible de l'écouter ...

Pour ajouter des stations avec Radiotray on peut utiliser l'interfaçe graphique précédente, mais si on veut en ajouter plusieurs on aura plus vite fait d'aller modifier directement le fichier de configuration !

Ce fichier de configuration se trouve ici: $HOME/.local/share/radiotray/bookmarks.xml

Donc, pour les radios principales de Radio France on ajoute dans le fichier le groupe "Radio France":

    <group name="Radio France">
        <bookmark name="France Inter" url="http://direct.franceinter.fr/live/franceinter-midfi.mp3"/>
        <bookmark name="France Info" url="http://direct.franceinfo.fr/live/franceinfo-midfi.mp3"/>
        <bookmark name="France Culture" url="http://direct.franceculture.fr/live/franceculture-midfi.mp3"/>
        <bookmark name="France Musique" url="http://direct.francemusique.fr/live/francemusique-midfi.mp3"/>
    </group>

Ensuite, on pourra aisément ajouter d'autres stations du groupe en piochant dans la liste des flux mp3.

Par exemple, pour les stations musicales de Radio France, on peut créer un sous-groupe du groupe Radio France que l'on nommera France Musique !

- page 2 de 54 -