protected void init() {
        String classpath = System.getProperty(JarClassLoader.P_ONE_JAR_CLASS_PATH);
        if (classpath != null) {
            String tokens[] = classpath.split("\\" + JarClassLoader.P_PATH_SEPARATOR);
            List list = new ArrayList();
            for (int i=0; i<tokens.length; i++) {
                String path = tokens[i];
                try {
                    list.add(new URL(path));
                } catch (MalformedURLException mux) {
                    // Try a file:// prefix and an absolute path.
                    try {
                    	String _path = new File(path).getCanonicalPath();
                    	// URLClassLoader searches in a directory if and only if the path ends with '/':
                    	// toURI() takes care of adding the trailing slash in this case so everything's ok
                        list.add(new File(_path).toURI().toURL());
                    } catch (Exception ignore) {
                        WARNING("Unable to parse external path: " + path + ":- " + ignore);
                    }
                }
            }
            final URL urls[] = (URL[])list.toArray(new URL[0]);
            INFO("external URLs=" + Arrays.asList(urls));
            // BUG-2833948
            // Delegate back into this classloader, use ThreadLocal to avoid recursion.
            externalClassLoader = (URLClassLoader)AccessController.doPrivileged(
                new PrivilegedAction() {
                    public Object run() {
                        return new URLClassLoader(urls, JarClassLoader.this) {
                            // Handle recursion for classes, and mutual recursion for resources.
                            final static String LOAD_CLASS = "loadClass():";
                            final static String GET_RESOURCE = "getResource():";
                            final static String FIND_RESOURCE = "findResource():";
                            // Protect entry points which could lead to recursion.  Strangely
                            // inelegant because you can't proxy a class.  Or use closures.
                            public Class loadClass(String name) throws ClassNotFoundException {
                                if (reentered(LOAD_CLASS + name)) {
                                    throw new ClassNotFoundException(name);
                                }
                                VERBOSE("externalClassLoader.loadClass(" + name + ")");
                                Object old = current.get();
                                current.set(LOAD_CLASS + name);
                                try {
                                    return super.loadClass(name);
                                } finally {
                                    current.set(old);
                                }
                            }
                            public URL getResource(String name) {
                                if (reentered(GET_RESOURCE + name))
                                    return null;
                                VERBOSE("externalClassLoader.getResource(" + name + ")");
                                Object old = current.get();
                                current.set(GET_RESOURCE + name);
                                try {
                                    return super.getResource(name);
                                } finally {
                                    current.set(old);
                                }
                            }
                            public URL findResource(String name) {
                                if (reentered(FIND_RESOURCE + name)) 
                                    return null;
                                VERBOSE("externalClassLoader.findResource(" + name + ")");
                                Object old = current.get();
                                current.set(name);
                                try {
                                    current.set(FIND_RESOURCE + name);
                                    return super.findResource(name);
                                } finally {
                                    current.set(old);
                                }
                            }
                            protected boolean reentered(String name) {
                                // Defend against null name: not sure about semantics there.
                                Object old = current.get();
                                return old != null && old.equals(name);
                            }
                        };
                    }
                });
                
        }
    }