Développer une application modulaire en Java

De base, Java utilise le ClassLoader système pour charger les classes dont notre application a besoin et ce ClassLoader contient les classes de notre application et toutes les classes qu'il a pu découvrir dans le classpath de celle-ci.

Le problème est que dans notre cas, on ne peut pas vraiment ajouter les fichiers Jar des modules au classpath étant donné que l'application ne les connait pas.

Nous allons donc devoir créer un nouveau ClassLoader avec lequel nous allons charger les classes de nos modules.

Il nous faudra donc procéder en deux phases :

• la première servira à explorer les fichiers des modules, à en sortir la classe du module et à récolter les URL des fichiers Jar ;
• la seconde va charger les différents modules en se servant d'un ClassLoader créé à partir des URL collectées durant la première phase.

On va donc créer une classe ModuleLoader qui va nous permettre d'effectuer ces phases.

Prenons maintenant la première phase et créons une méthode qui retourne la liste des classes à charger.

public class ModuleLoader { 
    private static List<URL> URL = new ArrayList<URL>(); 
 
    private static List<String> getModuleClasses(){ 
        List<String> classes = new ArrayList<String>(); 
 
        //On liste les fichiers de module  
        File[] files = new File("dossier").listFiles(new ModuleFilter()); 
 
        for(File f : files){ 
            JarFile jarFile = null; 
 
            try { 
                //On ouvre le fichier JAR 
                jarFile = new JarFile(f); 
 
                //On récupère le manifest 
                Manifest manifest = jarFile.getManifest(); 
 
                //On récupère la classe 
                String moduleClassName = manifest.getMainAttributes().getValue("Module-Class"); 
 
                classes.add(moduleClassName); 
 
                URL.add(f.toURI().toURL()); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } finally { 
                if(jarFile != null){ 
                    try { 
                        jarFile.close(); 
                    } catch (IOException e) { 
                        e.printStackTrace(); 
                    } 
                } 
            } 
        } 
 
        return classes; 
    } 
 
    private static class ModuleFilter implements FileFilter { 
        @Override 
        public boolean accept(File file) { 
            return file.isFile() && file.getName().toLowerCase().endsWith(".jar"); 
        } 
    } 
}

Comme vous le voyez, ce n'est pas très compliqué, on parcourt les fichiers Jar existants dans le dossier des modules, on ouvre le fichier Jar, on récupère le manifest et on récupère la classe du module. Ensuite, on ajoute l'URL du fichier Jar à la liste des URL.

Bien entendu ce code est perfectible, il faudrait traiter le cas où le fichier JAR n'a pas de manifest ou alors le cas où le manifest n'a pas de classe de module et il faudrait traiter les erreurs correctement, mais ce n'est pas le but de ce billet.

On peut maintenant passer à la deuxième méthode qui va créer le ClassLoader et instancier les modules puis les retourner :

private static ClassLoader classLoader; 
 
public static List<IModule> loadModules(){ 
    List<IModule> modules = new ArrayList<IModule>(); 
 
    List<String> classes = getModuleClasses(); 
 
    AccessController.doPrivileged(new PrivilegedAction<Object>(){ 
        @Override 
        public Object run() { 
            classLoader = new URLClassLoader( 
            URL.toArray(new URL[URL.size()]),  
            ModuleLoader.class.getClassLoader()); 
 
            return null; 
        } 
    }); 
 
    for(String c : classes){ 
        try { 
            Class<?> moduleClass = Class.forName(c, true, classLoader); 
 
            if(IModule.class.isAssignableFrom(moduleClass)){ 
                Class<IModule> castedClass = (Class<IModule>)moduleClass; 
 
                IModule module = castedClass.newInstance(); 
 
                modules.add(module); 
            }  
        } catch (ClassNotFoundException e1) { 
            e1.printStackTrace(); 
        } catch (InstantiationException e) { 
            e.printStackTrace(); 
        } catch (IllegalAccessException e) { 
            e.printStackTrace(); 
        } 
    } 
 
    return modules; 
}

On commence donc à créer un nouveau ClassLoader à partir des URL qu'on a récupéré avec les fichiers JAR. On va utiliser un URLClassLoader qui permet de charger des classes depuis des emplacements définis par des URL. On va lui donner comme parent le ClassLoader de la classe. Comme cela les modules qui utiliseront ce classloader pourront également utiliser les classes de l'application, ce qui est le but d'une application modulaire. Une fois qu'on a créé notre ClassLoader, on va parcourir toutes nos classes et les instancier si elles implémentent bien la bonne interface. Ensuite, on va pouvoir les ajouter à la liste et les retourner.

Encore une fois, ce code est perfectible, il faudrait traiter les erreurs et réagir aux différents cas possibles, mais j'ai essayé de faire au plus court.

Notre chargeur de modules est donc terminé.

La technique présentée dans ce billet pose néanmoins un problème pour ce qui est du déploiement à la volée de module. En effet, si on charge un module après le chargement des premiers modules, on devra recréer un nouveau ClassLoader et on aura donc une partie des modules dans le premier ClassLoader et une partie des modules dans le second ClassLoader. Néanmoins, si les modules n'ont aucune interaction entre eux, vous pouvez tout à fait envisager cette méthode pour le déploiement à la volée. Si ce n'est pas le cas, vous serez obligé de vous rabattre sur la méthode par réflexion pour ajouter des modules dans votre ClassLoader. Je présenterai peut-être cette méthode dans un prochain billet.

Le fait d'avoir un deuxième ClassLoader pose également un problème pour les librairies qui chargent des classes à la volée par exemple Spring IOC ou Hibernate. Il faut voir au cas par cas pour ces librairies comment on peut leur spécifier d'utiliser notre ClassLoader. Souvent ceci est faisable en spécifiant le contextClassLoader via la méthode Thread.currentThread().setContextClassLoader(ClassLoader cl).

Le ClassLoader système n'est, de base, pas fait pour être modifié. Néanmoins, au vu des complications qui se pose avec l'emploi d'un nouveau ClassLoader, il peut sembler beaucoup plus pratique d'ajouter nos fichiers JAR directement dans le ClassLoader système.

On peut assez facilement réaliser cette opération. Néanmoins, cette façon de faire nécessite d'utiliser des méthodes privées du ClassLoader pour ajouter des JAR après sa création.

En effet, l'URLClassLoader a une méthode addUrl qui permet de lui rajouter une URL. On peut donc invoquer cette méthode pour ajouter une URL dans la liste des endroits où le ClassLoader va chercher pour charger une classe.

Voici une méthode permettant d'ajouter une URL au ClassLoader système :

public static void addURLToSystemClassLoader(URL u) throws IOException { 
    URLClassLoader systemClassLoader = (URLClassLoader) ClassLoader.getSystemClassLoader(); 
    Class<URLClassLoader> classLoaderClass = URLClassLoader.class; 
 
    try { 
        Method method = classLoaderClass.getDeclaredMethod("addURL", new Class[]{URL.class}); 
        method.setAccessible(true); 
        method.invoke(systemClassLoader, new Object[]{u}); 
    } catch (Throwable t) { 
        t.printStackTrace(); 
        throw new IOException("Impossible d'ajouter l'URL au ClassLoader. "); 
    } 
}

Comme vous le voyez, on ne fait qu'utiliser la Reflection pour ajouter une URL au ClassLoader. Cette méthode est valable pour tout URLClassLoader.

Néanmoins, je vous déconseille d'utiliser cette méthode à moins d'en avoir vraiment besoin. Il est plus propre d'utiliser son propre ClassLoader.