Java / Log4J : Console & fichier LOG

LOG4J n'est plus à présenter : API puissante et indispensable pour tout développeur Java qui souhaite tracer certaines informations.

Nous allons nous attarder sur la façon "d'orienter" les traces vers la console et vers un fichier LOG.

Exemple d'un fichier log4j.properties.

Pour rappel ce fichier est le principal fichier pour le paramétrage de LOG4J.

log4j.rootLogger= , A1, A2

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.Threshold=INFO

log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d %-5p [%t] %-17c{2} (%13F:%L) %3x - %m%n

log4j.appender.A2=org.apache.log4j.RollingFileAppender
log4j.appender.A2.Threshold=INFO
log4j.appender.A2.File= ${user.home}/mon_fichier.log

log4j.appender.A2.MaxFileSize=5000KB
log4j.appender.A2.MaxBackupIndex=1

log4j.appender.A2.layout=org.apache.log4j.PatternLayout
log4j.appender.A2.layout.ConversionPattern=%d %-5p [%t] %-17c{2} %3x - %m%n

Dans cet exemple nous utilisons 2 "loggers" (autrement dit 2 "canaux" pour tracer les informations).

Le premier logger (A1) est la console.

Toutes les informations de type "INFO" seront tracées dans la console avec un format particulier (ConversionPattern).

Le deuxième logger (A2) : il va permettre de tracer les informations de type "INFO" dans un fichier LOG (mon_fichier.log).

A noter l'utilisation de ${user.home} qui spécifie le répertoire "HOME" de l'utilisateur.

Ce fichier est de type "RollingFile" : lorsque sa taille sera de 5000 KB (MaxFileSize) il sera automatiquement "vidé".

Le gros avantage de cette méthode est de pouvoir contrôler la taille des fichiers LOG.

L'inconvénient est de bien définir la taille du fichier selon nos besoins.

LOG4J permet aussi d'archiver ce type de fichier lorsqu'il a atteint la taille maximale. La propriété <MaxBackupIndex> définie le nombre de fichiers "archives" souhaité.

Les informations tracées dans le fichier sont formatées (ConversionPattern).

Java / Design Pattern Stratégie

Le pattern stratégie est utile pour des situations où il est nécessaire de choisir dynamiquement un algorithme à exécuter.

Vous mettez en place une stratégie dans l'exécution de votre code selon le contexte.

Par exemple : vous souhaitez gérer la première exécution d'une application nouvellement installée.

Lors de la première exécution, il est souvent demandé de saisir certaines informations utiles à l'application.

Il peut arriver que vous stoppiez pour différentes raisons cette saisie d'informations.

Lors d'une prochaine exécution de votre application, il vous sera demandé de compléter cette saisie d'informations inachevée.

Le pattern stratégie peut être utile pour définir quelles sont les données restantes à saisir.

Voici un exemple d'implémentation en Java.

Définissons d'abord notre <Strategy Manager>, c'est notre point d'entrée.

public class StrategyManager {
private static StrategyManager instance = null;

// contexte d'exécution
private StrategyContext ctx;

/**
* @return instance StrategyManager
* 
* @throws Exception
*/
public static StrategyManager getInstance() throws Exception {
if (instance == null)
instance = new StrategyManager();

return instance;
}

/**
* exécuter stratégie de lancement
*
* @throws Exception
*/
public void execCtx() throws Exception {
ctx.exec();
}

/**
* @throws Exception
*/
private StrategyManager()
throws Exception {
ctx = new StrategyContext();

  boolean etat = getEtat();

if (etat == 1) 
ctx.setStrategy(new Launch1());
else if (etat == 2)
ctx.setStrategy(new Launch2());
 else
// erreur
}

private int getEtat() {
   int etat = 0;

   // définir l'état qui correspond au contexte que vous souhaitez traiter

  return etat;
} 

}

Vous avez noté que nous avons utilisé un autre pattern, le pattern Singleton. De cette façon nous manipulons qu'une seule instance de notre manager.

Définissons la gestion du contexte <Strategy Context>.

public class StrategyContext {
private IStrategy strategy;

/**
* fixe la stratégie
* 
* @param strategy
*            : stratégie à appliquer
*/
public void setStrategy(IStrategy strategy) {
this.strategy = strategy;
}

/**
* exécuter stratégie sélectionnée
* 
         * @return 

* @throws Exception
*/
public boolean exec() throws Exception {
return strategy.go();
}
}

public interface IStrategy {

/**
* exécuter le code propre à la stratégie choisie
* 
* @throws Exception
*/
public boolean go() throws Exception;
}

Définissons maintenant les différents algorithmes qui peuvent être utilisés selon le contexte.

public class Launch1 implements IStrategy {

public Launch1() {

super();

}

/**

* exécuter stratégie lancement de type 1

*/

@Override

public boolean go() throws Exception {

           boolean resp = true;

           // votre code...

          return resp;

        }

}

public class Launch2 implements IStrategy {

public Launch2() {

super();

}

/**

 * exécuter stratégie lancement de type 2

 */

@Override

public boolean go() throws Exception {

           boolean resp = true;

           // votre code...

          return resp;

        }

}

La dernière étape : comment utiliser notre pattern stratégie ?

StrategyManager instance = StrategyManager.getInstance();

boolean resp = instance.execCtx();

if (!resp) {

  // erreur

}

Un des avantages de ce pattern est la possibilité d'ajouter ou de modifier un algorithme facilement sans réellement toucher au "corps" du traitement.

Java et les opérateurs

Les opérateurs en Java sont souvent mal utilisés et disons - le mal compris.

Vous trouverez dans cet article un moyen de tester le résultat des différents opérateurs que vous pouvez être amenés à utiliser.

Source

public class TestOperateurs {

 public static void main(String args[]) {
    int a = 1;
    int b = 2;
    int c = 0;

    c = a & b;      
    System.out.println("a & b = " + c );

    c = a | b;      
    System.out.println("a | b = " + c );

    c = a ^ b;     
    System.out.println("a ^ b = " + c );

    c = ~a;         
    System.out.println("~a = " + c );

    c = a << 2;     
    System.out.println("a << 2 = " + c );

    c = a >> 2;     
    System.out.println("a >> 2  = " + c );

    c = a >>> 2;    
    System.out.println("a >>> 2 = " + c );
 }
} 

Vous avez juste à initialiser les valeurs des variables <a>, <b> et <c>.

Android Studio Mac : conseils d'installation

Lorsque nous installons Android Studio version Mac pour la première fois, quelques erreurs peuvent apparaître.

Par définition les développeurs n'aiment pas les erreurs - autant partir sur une base "saine".

Par exemple une erreur sur une version du JDK Java non installée.

OS X n'installe plus depuis un certain temps les dernières versions du JDK Java - c'est donc à la charge de l'utilisateur de le faire.

Vous devez donc vous assurer que le bon JDK Java soit installé et que le <SDK Location> "pointe" bien sur ce JDK.

Pour la plateforme Android 5 (Lollipop) par exemple le JDK 7 est requis.

Autre erreur : lorsque Gradle (outil d'automation du build de votre application) est exécuté, ce message peut aussi apparaître :

"Gradle : No resource found that matches the given name ..."

En général vous pouvez avoir une centaine d'erreurs de ce type.
Pour résoudre ce problème, cliquez dans un premier temps sur le SDK Manager    et vérifiez que les composants ci-dessous soient installés :

Ensuite quelques modifications dans les propriétés de votre <App> (<open Module settings>).

Dans l'onglet "Properties", veuillez choisir comme <compile SDK version> la dernière version du build d'Android.

Il n'est pas obligatoire de changer la version du SDK pour la <target> de votre application (onglet "Flavors") mais il est recommandé de choisir la dernière version du build d'Android.

Vous pouvez faire la même chose en modifiant directement le fichier <build.gradle>.

Une fois ces modification appliquées, synchronisez votre projet à nouveau.