jeudi 24 décembre 2015

JavaScript, les bonnes résolutions 2016

S'il y a bien un langage que tout le monde déteste, c'est bien JavaScript.
Pourtant, force est de constater que personne n'a réussi à le "tuer". C'est même tout le contraire qui s'est passé.
Devant l'échec de GWT ou Dart à s'imposer, on ne peut qu'admirer la progression fulgurante de NodeJS, AppJS ou Electron.

Alors pourquoi tant de monde le déteste ? D'une part, il suffit de citer la définition de Wikipédia pour comprendre, qu'on ne comprend rien :

C’est un langage orienté objet à prototype, c’est-à-dire que les bases du langage et ses principales interfaces sont fournies par des objets qui ne sont pas des instances de classes, mais qui sont chacun équipés de constructeurs permettant de créer leurs propriétés, et notamment une propriété de prototypage qui permet d’en créer des objets héritiers personnalisés. En outre, les fonctions sont des objets de première classe.


et d'autre part, il y a plein de moteur JS différents qui apporte donc une implémentation différente et des bugs différents.
JavaScript c'est quoi ?
Javascript n'est pas un langage objet ! Même si on le voit écrit partout c'est faux.
Pour rappel un langage object c'est :
  • classe,
  • polymorphisme,
  • héritage,
  • objet,
  • encapsulation,
  • messages.
La portée des variables, ce ne sera plus un mystère
Si vous définissez une variable sans mot clef var devant, votre variable sera globale (non, pas d'erreur de type variable non définie).
Si vous utilisez le mot clef var, la variable aura la porté de la fonction où elle est définie.

Exemple :
// Si les déclarations sont hors fonction, ça revient au même
variableGlobale = 1;
var variableGlobale = 2;

function toto() {
    // variableGlobale est accessible, modifiable...
    var local = variableGlobale;

    // local vaut 2
    variableGlobale = 3;

    for (var index = 0; index < 3; index++) {
        // un block : for, while... n'est pas une fonction !
        // index sera donc accessible en dehors de ce bloc.
        // Si on veut une variable locale, il faut être un EcmaScript 6 et utiliser le mot clef let !
    }
}

// variableGlobale vaut 3
// local n'existe pas.
Il faut noter qu'une variable globale est accessible avant d'être créée !
La portée des fonctions, ce ne sera plus un mystère
Pour les fonctions, il faut bien avouer que c'est un peu plus compliqué.
Si vous déclarer une fonction comme ceci : function helloWorld(), alors la fonction sera globale et accessible avant même d'être déclarée.

Par contre, si vous déclarez la fonction sans le mot clef function, la fonction ne sera accessible qu'après avoir été déclarée.
La porté des variables : le contexte de la fonction avec this
Nous l'avons vu pour les variables, une fonction limite la portée des variables.
En effet, une fonction a un contexte, le fameux mot clef this. Et oui this représente la fonction en cours !

Exemple :
function toto() {
    // this représente la fonction toto()
    var func = function() {
        // this représente la fonction func()
    };
}

Pour conserver le contexte d'une fonction, il donc stocker le contexte dans une variable :
function toto() {
    var me = this;
    // this et 'me' représente la fonction toto()
    var func = function() {
        var me = this;
        // this et 'me' représente la fonction func()
    };

    // 'me' représente toujours la fonction toto()
}
Allez encore plus loin
Inutile que je répète ce qui a déjà été très bien expliqué !
Je vous conseille de lire cette page : braincracking.org.

Pour votre culture, le premier langage par prototype : Self.

jeudi 11 juin 2015

Java et la réflexion [4/4]

Maintenant que vous maîtriser les annotations et la réflexion en java, voici le code source complet du convertissant Java -> Mongo/Mongo -> Java :
package mongodb.tools;


import mongodb.tools.annotation.Id;
import mongodb.tools.annotation.Ignore;
import mongodb.tools.annotation.Version;
import mongodb.tools.exception.VersionMismatchException;
import org.bson.Document;
import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;

import java.beans.Introspector;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.*;

/**
 * Created by emeric_martineau on 11/03/2015.
 */
public class MongoDbMapping {
    /**
     * Field name of version.
     */
    public static final String VERSION_FIELD = "<version>";

    /**
     * Map to map primitive class.
     */
    private static final Map<Class<?>, Class<?>> primitiveMap = new HashMap<Class<?>, Class<?>>();

    static {
        primitiveMap.put(Boolean.TYPE, Boolean.class);
        primitiveMap.put(Byte.TYPE, Byte.class);
        primitiveMap.put(Character.TYPE, Character.class);
        primitiveMap.put(Short.TYPE, Short.class);
        primitiveMap.put(Integer.TYPE, Integer.class);
        primitiveMap.put(Long.TYPE, Long.class);
        primitiveMap.put(Double.TYPE, Double.class);
        primitiveMap.put(Float.TYPE, Float.class);
        primitiveMap.put(Void.TYPE, Void.TYPE);
    }

    /**
     * Convert object to MondogDB object. Support direct object (int, String...) and Iterable. Not support array, Map...
     *
     * @see mongodb.tools.annotation.Ignore
     * @see mongodb.tools.annotation.Id
     *
     * @param obj object to convert
     *
     * @return mongodb object
     *
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    public static Document toMongo(final Object obj)
            throws InvocationTargetException, IllegalAccessException {
        Document result;

        if (obj == null) {
            result = null;
        } else {
            result = new Document();

            Class tClass = obj.getClass();
            Version versionAnnotation = (Version) tClass.getAnnotation(Version.class);

            if (versionAnnotation != null) {
                result.append(VERSION_FIELD, versionAnnotation.version());
            }

            Method[] methods = tClass.getMethods();

            String methodName;

            // Fielname
            String fieldName;
            // Data of field
            Object data;
            // Use if data is iterable
            List temporaryList;
            // Current object of list
            Object objList;

            for (int i = 0; i < methods.length; i++) {
                methodName = methods[i].getName();

                if (methodName.startsWith("get") && !"getClass".equals(methodName)
                        && !methods[i].isAnnotationPresent(Ignore.class)
                        && !methods[i].isAnnotationPresent(Id.class)) {
                    // Found getter.
                    fieldName = Introspector.decapitalize(methods[i].getName().substring(3));

                    if (methods[i].getParameterCount() == 0) {
                        data = methods[i].invoke(obj);

                        if (data instanceof Iterator) {
                            Iterator it = ((List) data).iterator();
                            temporaryList = new LinkedList();

                            while (it.hasNext()) {
                                objList = it.next();

                                temporaryList.add(toMongo(objList));
                            }
                        }

                        result.append(fieldName, data);
                    }
                }
            }
        }

        return result;
    }

    /**
     * Convert MongoDb object to POJO
     *
     * @param mongoObj mongodb object
     * @param clazz class to instanciate
     *
     * @return object
     *
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws VersionMismatchException if object is strict and version not match
     */
    public static Object fromMongoDb(final Document mongoObj, final Class clazz)
            throws IllegalAccessException, InstantiationException, VersionMismatchException, InvocationTargetException, ClassNotFoundException {
        Object result;

        if (mongoObj == null) {
            result = null;
        } else {
            result = clazz.newInstance();
            Class tClass = result.getClass();
            Method[] methods = tClass.getMethods();

            /* Class annotation */
            Version versionAnnotation = (Version) tClass.getAnnotation(Version.class);

            String property;
            Object value;

            /* Setter method */
            Method setter;
            /* Parameter of setter */
            Class<?> parameter;
            Type[] type;

            for (Map.Entry<String, Object> setKey : mongoObj.entrySet()) {
                property = setKey.getKey();
                value = setKey.getValue();

                if (VERSION_FIELD.equals(property)) {
                    // Check version
                    if (versionAnnotation != null && versionAnnotation.strict()) {
                        int version = Integer.valueOf((String) value);

                        if (version != versionAnnotation.version()) {
                            throw new VersionMismatchException(String.format("Version %d found, version %d expected.",
                                    version, versionAnnotation.version()));
                        }
                    }
                } else {
                    setter = findSetter(methods, property);

                    if (setter != null) {
                        parameter = setter.getParameterTypes()[0];
                        type = setter.getGenericParameterTypes();

                        if (parameter.isPrimitive()) {
                            invokePrimitive(result, setter, parameter, value);
                        } else if (parameter.isEnum()) {
                            invokeEnum(result, setter, parameter, value);
                        } else if (parameter.isArray()) {
                            // TODO
                        } else if (parameter.getName().equals("java.lang.String")) {
                            setter.invoke(result, value);
                        } else if (parameter == List.class) {
                               invokeList(result, setter, type, value);
                        }

                        System.out.println(parameter);
                        // si c'est un talbeau
                        // si c'est une map
                    }
                }
            }
        }

        return result;
    }

    /**
     * Find method setter with only one parameter.
     *
     * @param methods methods list
     * @param fieldName fieldName
     *
     * @return method
     */
    private static Method findSetter(final Method[] methods, final String fieldName) {
        String methodName = "set".concat(Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1));
        System.out.println(fieldName);
        // Search method
        Method m = null;

        for (Method currentMethod : methods) {
            if (methodName.equals(currentMethod.getName())) {
                // Now check only one parameter
                if (currentMethod.getParameterCount() == 1) {
                    m = currentMethod;
                    break;
                }
            }
        }

        return m;
    }

    /**
     * Invoke primitive setter.
     *
     * @param obj object to call setter
     * @param m method to call
     * @param parameter parametter of setter
     * @param value value to setup
     *
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    private static void invokePrimitive(Object obj, Method m, Class<?> parameter, Object value)
            throws InvocationTargetException, IllegalAccessException {
        if (parameter == Boolean.TYPE) {
            m.invoke(obj, Boolean.valueOf((String) value));
        } else if (parameter == Byte.TYPE) {
            m.invoke(obj, Byte.valueOf((String) value));
        } else if (parameter == Character.TYPE) {
            m.invoke(obj, Character.valueOf((char) value));
        } else if (parameter == Short.TYPE) {
            m.invoke(obj, Short.valueOf((String) value));
        } else if (parameter == Integer.TYPE) {
            m.invoke(obj, Integer.valueOf((String) value));
        } else if (parameter == Long.TYPE) {
            m.invoke(obj, Long.valueOf((String) value));
        } else if (parameter == Double.TYPE) {
            m.invoke(obj, Double.valueOf((String) value));
        } else if (parameter == Float.TYPE) {
            m.invoke(obj, Float.valueOf((String) value));
        }
    }

    /**
     * Invoke enum setter.
     *
     * @param obj object to call setter
     * @param m method to call
     * @param parameter parametter of setter
     * @param value value to setup
     *
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    private static void invokeEnum(Object obj, Method m, Class<?> parameter, Object value)
            throws InvocationTargetException, IllegalAccessException {
        Enum enumValue = Enum.valueOf((Class<Enum>) parameter, (String) value);

        m.invoke(obj, enumValue);
    }

    /**
     * Invoke collection setter.
     *
     * @param obj object to call setter
     * @param m method to call
     * @param parameter parametter of setter
     * @param value value to setup
     *
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private static void invokeList(Object obj, Method m, Type[] parameter, Object value)
            throws InvocationTargetException, IllegalAccessException, InstantiationException,
            VersionMismatchException, ClassNotFoundException {
        List srcList = (List) value;
        List destList = null;

        Class classOfList = getGenericClass(parameter);

        if (value != null) {
            destList = new ArrayList(srcList.size());

            for (Object item : srcList) {
                if (item == null) {
                    destList.add(null);
                }else if (item instanceof Document) {
                    fromMongoDb((Document) item, classOfList);
                } else {
                    destList.add(item);
                }
            }
        }

        m.invoke(obj, destList);
    }

    /**
     * Found type of generic
     *
     * @param parameter parameter of method
     *
     * @return class to be instanciate
     *
     * @throws ClassNotFoundException
     */
    private static Class getGenericClass(Type[] parameter) throws ClassNotFoundException {
        Type type = ((ParameterizedTypeImpl) parameter[0]).getActualTypeArguments()[0];

        return Class.forName(type.getTypeName());
    }
}

vendredi 5 juin 2015

Java et la réflexion [3/4]

Une partie intéressant de la reflexion est la lecture des annotations.

Qu'est-ce que les annotation ?

Les annotation sont des métadonnées (des données supplémentaires) ajoutée à une classe, un attribut, une méthode.

Il existe 3 types d'annotations :
  • SOURCE : ces annotations sont ignorées par le compilateur mais produisent par exemple un message à la compilation comme @Override, @SuppressWarnings,
  • CLASS : ajoute des métadonnées à la classe mais ne sont pas accessibles à l'exécution,
  • RUNTIME : c'est ce type d'annotation qu'on va utiliser.

Reprenons l'exemple de MongoDB. Nous allons créer un simple mapper entre des objets java et du mongo.

Pour cela nous allons créer 3 annotations.
  • @Id : qui permet d'indiquer que la méthode est le getter/setter de l'ID MongoDB,
  • @Ignore : qui indique de ne pas mapper l'attribut de la classe java,
  • @Version : qui indique la version de l'objet

mongodb.tools.annotation.Id :
package mongodb.tools.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * To indicate that setter is for MongoDb Id.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Id {
}

mongodb.tools.annotation.Ignore :
package mongodb.tools.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Ignore method.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Ignore {
}

mongodb.tools.annotation.Version :
package mongodb.tools.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * To indicate that setter is for MongoDb Id.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Version {
    /**
     * Version of object.
     *
     * @return
     */
    public int version();

    /**
     * If strict when unserialize. Raise error if not same version.
     * @return
     */
    public boolean strict() default false;
}

Imaginons la méthode toMongo() qui convertit un object java en object MondoDB.
public static Document toMongo(final Object obj)
        throws InvocationTargetException, IllegalAccessException {
    Document result;

    if (obj == null) {
        result = null;
    } else {
        result = new Document();

        Class tClass = obj.getClass();
        Version versionAnnotation = (Version) tClass.getAnnotation(Version.class);

        if (versionAnnotation != null) {
            result.append(VERSION_FIELD, versionAnnotation.version());
        }
            
...

Nous prenons donc la classe de l'objet et sur cette classe nous récupérons l'annotation de type Version.class.
Il est important de noter que les annotations ne sont pas héritable. C'est à dire que si la classe Toto à l'annotation Version et que la classe Titi hérite de la classe Toto, l'annotation n'est pas reporter sur la classe Toto.
Il faudra remonter dans la hiérarchie des héritages pour prendre toutes les annotations.

Pour les méthodes, c'est à peu près identique :
...

Method[] methods = tClass.getMethods();

for (int i = 0; i < methods.length; i++) {
                methodName = methods[i].getName();

    if (methodName.startsWith("get") && !"getClass".equals(methodName)
            && !methods[i].isAnnotationPresent(Ignore.class)
            && !methods[i].isAnnotationPresent(Id.class)) {
...

Voilà, ce n'est pas plus difficile que ça.

vendredi 17 avril 2015

Java et la réflexion [2/4]

Les méthodes
Récupération des méthodes public
Afin de récupérer les méthodes publics d'une classe, il faut utiliser la méthode getMethods(). Cette méthode ne retourne pas les méthodes privées !
Vous récupérez un object Method. Cet objet récupéré, va permettre d'appeler la méthode avec ou sans paramètre, connaitre les types de paramètres attendus...
Récupération des paramètres des méthodes
Avec Java 8, il est très facile de savoir si une méthode attend des paramètes ou non avec la méthode Method.getParameterCount().
Si la méthode attend des paramètres, il est possible de les récupérer via la méthode getParameterTypes().
Détecter si le paramètre est de type primitif
Une fois le paramètre obtenu, il est important de savoir si ce paramètre est un primitif au non, afin de convertir correctement la donnée à entrer.
Partons du postulat que nous avons une chaine de caracètre que nous souhaitons convertir vers un type primitif :
// L'objet sur lequel on fait de la reflexion
Object obj = ...;
// Le setter a utiliser
Method setter = ....;
// On suppose qu'il n'y a paramètre au setter
Class parameter = setter.getParameterTypes()[0];

if (parameter.isPrimitive()) {
    if (parameter == Boolean.TYPE) {
        m.invoke(obj, Boolean.valueOf(value));
    } else if (parameter == Byte.TYPE) {
        m.invoke(obj, Byte.valueOf(value));
    } else if (parameter == Character.TYPE) {
        m.invoke(obj, Character.valueOf(value.substring(0, 1));
    } else if (parameter == Short.TYPE) {
        m.invoke(obj, Short.valueOf(value));
    } else if (parameter == Integer.TYPE) {
        m.invoke(obj, Integer.valueOf(value));
    } else if (parameter == Long.TYPE) {
        m.invoke(obj, Long.valueOf(value));
    } else if (parameter == Double.TYPE) {
        m.invoke(obj, Double.valueOf(value));
    } else if (parameter == Float.TYPE) {
        m.invoke(obj, Float.valueOf(value));
    }
}
Détecter si le paramètre est de type tableau
Pour savoir s'il s'agit d'un tableau en entrée de la méthode, il est possible d'utiliser la méthode isArray() sur le paramètre, comme pour isPrimitive()
Détecter si le paramètre est une énumération
Pour savoir s'il s'agit d'un enum, il est possible d'utiliser la méthode isEnum() sur le parametre, comme pour isPrimitive()
Détecter si le paramètre est de type List/Map...
A présent, pour savoir si le paramètre est un list, la solution est simple, comparer avec le classe en question, comme nous l'avons fait avec les primitifs. A savoir :
    if (parameter == List.class)
Récupération du générique de la liste
Pour récupérer le type du générique de la liste, là pas de longue explication, c'est en recherchant sur internet qu'on trouve des pistes, puis les expérimentations font le reste. Pour vous faire gagner du temps, voilà la solution :
Type[] parameter = setter.getGenericParameterTypes();

Type type = ((ParameterizedTypeImpl) parameter[0]).getActualTypeArguments()[0];

return Class.forName(type.getTypeName());
Oui, ça ne s'invente pas. A retenir, ((ParameterizedTypeImpl) parameter[0]) veut dire qu'on prend le premier paramettre de la méthode, getActualTypeArguments()[0] indique qu'on prend le premier paramètre générique. Et oui, pour une Map, il faudra prendre les 2 premiers.

dimanche 15 mars 2015

Java et la réflexion [1/4]

La reflexion en Java est un élément essentiel à connaitre. Ce n'est pas difficile en soit, mais certaines parties peuvent paraître un peu obscure.
A quoi la reflexion peut-elle servir ?
Par exemple, à faire un mapping d'objet facilement.
Prenons l'exemple de MongoDB. Actuellement le projet MongoJack qui permet de mapper les objets MongoDb en Java ne propose pas le support du driver MongoDb 3.
Nous allons donc écrire un petit mapper pour le driver MongoDb 3. L'exemple ne prendra pas en compte tous les types, seulement ceux intéressants dans le cadre d'un apprentissage.
Les base de la reflexion
La réflexion permet de découvrir les caractéristiques d'une classe (attributs, méthodes, annotation...). Ceci est très pratique pour faire un traitement générique. Dans notre cas, découvrir les getter pour créer un object Document du driver version 3 de MongoDb.
Les attributs
Récupération des attributs publics
Afin de récupérer les attributs publics d'une classe, il faut utiliser la méthode getFields(). Cette méthode ne retourne pas les attributs privés !
Vous récupérez un object Field sur lequel vous pourrez utiliser la méthode get() pour récupérer la valeur et set() pour modifier la valeur.

Exemple :
import java.lang.reflect.Field;

public class TestField {
    public String field1;
    private String field2;

    public TestField(String f1, String f2) {
        this.field1 = f1;
        this.field2 = f2;
    }

    public String getField2() {
        return this.field2;
    }

    public static void main(String[] args) throws IllegalAccessException {
        // Le type est volontairement objet pour prouver que même si on
        // ne connait pas le type, il est possible d'avoir les informations.
        Object o = new TestField("1", "2");

        // On ne connait pas l'objet mais tout object à getClass() qui retourne
        // la classe. De là on récupère les attributs public.
        Field[] fields = o.getClass().getFields();

        // On itère sur les attributs public
        for (Field f : fields) {
            System.out.println("Name : " + f.getName());
            System.out.println("Old Value : " + f.get(o));

            f.set(o, "9");
        }

        System.out.println("New Value : " + ((TestField) o).field1);
    }
}

Voici le résultat :
Name : field1
Old Value : 1
New Value : 9

On voit que le champ a bien été modifié.
Récupération des attributs privés
Pour récupérer les attributs privés, il faut utiliser la méthode getDeclaredFields() au lieu de getFields(). Toutefois, il faut, avant d'appeler la méthode get() rendre le champs accessible par setAccessible(true). Voici l'exemple :
        Field[] fields = o.getClass().getDeclaredFields();

        // On itère sur les attributs public
        for (Field f : fields) {
            // Rend le champs accessible
            f.setAccessible(true);
            
            System.out.println("Name : " + f.getName());
            System.out.println("Old Value : " + f.get(o));

            f.set(o, "9");
        }

Il faut noter que getFields() ou getDeclaredFields() ne retourne pas les attributs hérités. Pour cela il faudra utiliser la classe mère en la récupérant via getSuperclass().
Détecter si l'attribut est de type primitif
Pour savoir si un attribut est de type primitif et donc à ne pas instancier, il faut utiliser f.getType().isPrimitive(). Après, pour savoir de quel primitif il s'agit, il faut comparer le type avec le type primitif Boolean.TYPE, Byte.TYPE...
Détecter si l'attribut est de type tableau
Même chose avec les tableaux qu'avec les primitifs, il faut utiliser f.getType().isArray().
Détecter si l'attribut est de type List
Pour savoir si un attribut est de type List (ou autre), il faut simplement comparer le type avec la classe liste : f.getType() == List.class.
Récupération du générique de la liste
Pour savoir s'il s'agit d'un générique, il faut vérifier que le type renvoyé par f.getGenericType() est de type ParameterizedTypeImpl.
Exemple :
if (f.getGenericType() instanceof ParameterizedTypeImpl) {
    System.out.println(
            ((ParameterizedTypeImpl) f.getGenericType()).getActualTypeArguments()[0].getTypeName());
} 
Ensuite, il faut récupérer les arguments des types (getActualTypeArguments). Il s'agit d'une table. Dans le cas d'une liste, il n'y en a qu'un élément. Dans le cas d'une Map, il y en aura 2.