Discussion :

[Loicb]

Bonjour,

Le code de mon application est réparti dans une dizaine de .jar et utilise une quinzaine de jars de librairies externes.

Mon application tourne parfaitement si je définis une variable d'environnement CLASSPATH et que je la lance par
java -classpath %CLASSPATH% mon.package.MaClasse

Toutefois, ayant eu des erreurs dues à la longueur de la variable d'environnement sur certains systèmes (WinNT, MacOSX) j'ai essayé de réaliser un "loader", un peu comme le start.jar de Tomcat.

Le problème, c'est que quand j'utilise mon "loader", l'application se lance puis meurt subitement, sans prévenir, après quelques secondes d'exécution. Le plus étrange, c'est qu'il n'y a rien sur l'erreur qui provoque ça, ni dans les logs (j'utilise log4j), ni sur la console. Je ne retrouve même pas de fichier d'erreur indiquant un arrêt brutal de la JVM (violation d'accès ou autre).
J'ai ajouté un UncaughtExceptionHandler et un ShutdownHook pour essayer de voir ce qui se passe, mais rien à faire : toujours aucun log.

J'ai testé sous Windows 2000, Windows XP et MacOSX, avec les mêmes résultats à chaque fois (ràs si lancement par script, décès brutal si lancement via le "loader").

Voyez-vous une explication à cette abscence de traces sur la raison de cet arrêt ? Une idée sur comment identifier le problème ? Une bourde énorme dans mon code (ci-dessous) ?

la classe principale (le "main" du launcher)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
 
package mon.test;
 
import java.lang.reflect.Method;
 
public class Demarrer
{
 
    public static void main(String[] args)
    {
        // Définition du classpath
        System.setProperty("java.class.path",ClassPathBuilder.getStringValue());
 
        // Chargement d'un Classloader avec ce classpath
        ClassLoader loader = ClassPathBuilder.getClassLoader();
        Thread.currentThread().setContextClassLoader(loader);
 
        try
        {
            // Chargement de la classe principale
            Class mon_main = loader.loadClass("mon.package.MaClasse");
            // Lancement de l'application
            Method main = mon_main.getDeclaredMethod("main", new Class[] { args.getClass() });
            main.invoke(null, new Object[] { args });
        }
        catch(Throwable t)
        {
            System.err.println("Echec du lancement");
            t.printStackTrace(System.err);
        }
        System.exit(0);
    }
}

Et la classe ClassPathBuilder

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
 
package mon.test;
 
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.ResourceBundle;
 
public class ClassPathBuilder {
 
    /**
     * Les librairies à ajouter au Classpath sous tous les systèmes
     */
    private static String[] requiredLibs;
    /**
     * Les librairies à rajouter au classpath quand on est sous Windows
     */
    private static String[] win32Libs;
    /**
     * Les librairies à rajouter au classpath quand on est sous Mac
     */
    private static String[] macLibs;
 
    static
    {
        // Initialisation des librairies
        ResourceBundle rb = ResourceBundle.getBundle("classpath");
        int reqLibCount = Integer.parseInt(rb.getString("requiredLibs.count"));
        requiredLibs = new String[reqLibCount];
        for (int i = 0; i< reqLibCount; i++)
        {
            requiredLibs[i] = rb.getString("requiredLib." + i);
        }
 
        int win32LibCount = Integer.parseInt(rb.getString("win32Libs.count"));
        win32Libs = new String[win32LibCount];
        for (int i = 0; i< win32LibCount; i++)
        {
            win32Libs[i] = rb.getString("win32Lib." + i);
        }
 
        int macLibCount = Integer.parseInt(rb.getString("macLibs.count"));
        macLibs = new String[macLibCount];
        for (int i = 0; i< macLibCount; i++)
        {
            macLibs[i] = rb.getString("macLib." + i);
        }
    }
 
    private static final boolean isOnWindows = (System.getProperty("os.name").indexOf("Win") != -1);
    private static final boolean isOnMac = (System.getProperty("os.name").indexOf("Mac") != -1);
    private static HashMap<String,File> foundLibs = null;
 
    private static File trouverLibrairie(String nomLib)
    {
        File fichierLib = new File(nomLib);
        if (fichierLib.exists())
        {
            return fichierLib;
        }
        else
        {
            fichierLib = new File("./lib/" + nomLib);
            if (fichierLib.exists())
            {
                return fichierLib;
            }
        }
        System.err.println(nomLib + " requise mais non trouvee");
        return null;
    }
 
    private static HashMap<String,File> getFoundLibs()
    {
        if (foundLibs != null) return foundLibs;
        foundLibs = new HashMap<String,File>();
 
        int numLibs = requiredLibs.length;
        if (isOnWindows) numLibs += win32Libs.length;
        if (isOnMac) numLibs += macLibs.length;
 
        // Chargement des librairies communes
        for (int i=0; i < requiredLibs.length; i++)
        {
            File f = trouverLibrairie(requiredLibs[i]);
            if (f != null) foundLibs.put(requiredLibs[i], f);
        }
 
        // Et des librairies Windows s'il y a lieu
        if (isOnWindows)
        {
            for (int i=0 ; i < win32Libs.length ; i++)
            {
                File f = trouverLibrairie(win32Libs[i]);
                if (f != null) foundLibs.put(win32Libs[i], f);
            }
        }
 
        // Et des librairies Mac s'il y a lieu
        if (isOnMac)
        {
            for (int i=0 ; i < macLibs.length ; i++)
            {
                File f = trouverLibrairie(macLibs[i]);
                if (f != null) foundLibs.put(macLibs[i], f);
            }
        }
 
        return foundLibs;
    }
 
    /**
     * @return Le ClassLoader initialisé avec le classpath convenable pour l'application
     * 
     */
    public static ClassLoader getClassLoader()
    {
        URL[] urls = new URL[getFoundLibs().size()];
        Iterator<File> fichiers = getFoundLibs().values().iterator();
        for (int i=0; i < urls.length; i++)
        {
            try
            {
                urls[i] = fichiers.next().toURL();
            } catch (MalformedURLException e) {}
        }
 
        // Et on crée le ClassLoader avec les jars en paramètres
        ClassLoader parent = Thread.currentThread().getContextClassLoader();
        if (parent == null) {
            parent = ClassPathBuilder.class.getClassLoader();
        }
        if (parent == null) {
            parent = ClassLoader.getSystemClassLoader();
        }
        return new URLClassLoader(urls, parent);
    }
 
    public static String getStringValue()
    {
        StringBuilder sb = new StringBuilder();
        Iterator<File> fichiers = getFoundLibs().values().iterator();
        if (fichiers.hasNext()) {
            sb.append( fichiers.next().getPath() );
        }
        while (fichiers.hasNext()) {
            sb.append(File.pathSeparatorChar).append( fichiers.next().getPath() );
        }
        return sb.toString();
    }
 
}

Merci

[Pill_S]

Salut,

je ne sais pas vraiment quel est ton problème, mais une chose est sûre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
try
{
  urls[i] = fichiers.next().toURL();
} catch (MalformedURLException e) {}

il faut toujours mettre quelque chose dans un bloc catch, au moins un affichage console, et un "e.printStackTrace()" si tu as besoin de plus d'infos sur l'exception

Parce que là, impossible de dire ce qui se passe....

[Loicb]

D'accord pour le principe, je vais mettre un contenu ! ;-)

Mais ce code là (le "launcher"), lui, marche très bien (pas d'exception, les librairies sont bien trouvées). J'ai vérifié que la liste de librairies générée est correcte (identique à celle que je passe dans la variable d'environnement dans le script) : c'est le cas.
On arrive bien à l'invocation de la méthode "main".

L'"autre" appli (la principale) se lance bien, j'ai même vérifié que tous les threads que je crée ensuite héritent bien ce ClassLoader avec le classpath complet. C'est le cas. Donc à priori, ce qui fait planter mon appli n'est pas un NoClassDefFoundException (et si c'était ça, je pense que je l'aurais catchée).

Mais après quelques secondes, plus personne.
La dernière trace que je récupère est juste au-dessus d'un appel à Thread.sleep et celle en dessous n'apparaît jamais. Par contre impossible de dire si c'est l'appel à Thread.sleep qui fait partir la JVM en vrille ou si c'est un autre traitement qu'un autre thread exécute pendant ce temps (mais ce qui est sûr c'est que la dernière trace que je récupère est toujours la même - vous me direz c'est peut-être normal vu que c'est toujours la même application et que les threads sont démarrés dans le même ordre).

[jowo]

Commentaire

Pourquoi, pour le test, ne pas démarrer une apllication "simple" pour voir si elle tourne et après lui ajouter des fonctionnalités un peu plus "lourdes"?

Une autre possibilité est de lancer la JVM avec des options qui te permettent de suivre son déroulement.