Problem with dynamically setting the classpath at runtime

[pinjalim bora]

Hi...
I am trying to make a small tool to find the class hierarchy of a class given the name of the class with the complete package structure.
I am using Class.forName(classname) to load the classes dynamically and am finding its superclass...
Am also giving an option to change the classpath.I am setting it by using the following command
System.setProperty("java.class.path", existingclasspath + ";" + newclasspath +";"); where neclasspath is a string that is taken fro the user at runtime.
Although this tachnique is changing the classpath env variable but stilll Class.forName id throwwing ClassNotFoundException.How do i go about it.Am giving the whole code....
.Please help.................
Source Code
--------------------------------------------------------------------------

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
class ClassHierarchy extends JFrame implements ActionListener {
    int width = 400,height = 400;
    ClassHierarchy(String framename) {
        super(framename);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setSize(width, height);
        this.setResizable(false);
        //Puts the Frame in the middle of  the screen
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Dimension dim = toolkit.getScreenSize();
        this.setLocation((int) (dim.getWidth() - width) / 2, (int) (dim.getHeight() - height) / 2);
        basepanel = new JPanel();
        JLabel label = new JLabel("ClassName : ");
        text = new JTextField(10);
        JButton enter = new JButton("Enter");
        JButton setclspath = new JButton("Set Classpath");
        enter.setMnemonic('E');
        setclspath.setMnemonic('S');
        enter.addActionListener(this);
        setclspath.addActionListener(this);
        basepanel.add(label);
        basepanel.add(text);
        basepanel.add(enter);
        basepanel.add(setclspath);
        this.getContentPane().add(basepanel, BorderLayout.NORTH);
        pane = new JScrollPane();
        this.getContentPane().add(pane, BorderLayout.CENTER);
        show();
    }
    public void actionPerformed(ActionEvent click) {
        top = new DefaultMutableTreeNode("java.lang.Object");
        if (click.getActionCommand().equals("Enter")) {
            this.analyzer(text.getText(), top);
            if (top.getChildCount() != 0) {
                JTree tree = new JTree(top);
                tree.setShowsRootHandles(true);
                //Expands the whole tree
                int iRow = 0;
                while (iRow < tree.getRowCount()) {
                    tree.expandRow(iRow);
                    iRow++;
                }
                pane.getViewport().add(tree);
            }
        } else if (click.getActionCommand().equals("Set Classpath")) {
            JFileChooser dir = new JFileChooser();
            dir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
            int returnval = dir.showOpenDialog(this);
            if (returnval == JFileChooser.APPROVE_OPTION) {
                String file = dir.getSelectedFile().getAbsolutePath();
                ClassHierarchy.setClasspath(file);
            }
        }
    }
    private void analyzer(String classname, DefaultMutableTreeNode leaf) {
        DefaultMutableTreeNode temp = null;
        try {
            Class subclass = Class.forName(classname);
            if(subclass.isInterface())
            {
                      JOptionPane.showMessageDialog(null,
                          subclass.getName()+" is an interface", 
                          "Alert", JOptionPane.ERROR_MESSAGE);
            }
            else
            {
                    Class superclass = subclass.getSuperclass();
                    System.out.println(subclass.getName());
                    if (superclass != null) {
                        analyzer(superclass.getName(), leaf);
                    } else {
                         return;
                    }
                  temp = new DefaultMutableTreeNode(classname);
                  leaf.getLastLeaf().add(temp);
            }

        } catch (ClassNotFoundException e) {
            JOptionPane.showMessageDialog(null, 
                "Class Not Found.\n Please set the Class path properly",
                "Alert", JOptionPane.ERROR_MESSAGE);
        } catch (Exception finalex) {
            JOptionPane.showMessageDialog(null, 
                "FATAL ERROR", "Alert", JOptionPane.ERROR_MESSAGE);
        }
    }
    public static void main(String args[])
    {
        new ClassHierarchy("Class Hierarchy");
    }
     public static void setClasspath(String file) {
        String classpath = System.getProperty("java.class.path");
        if (classpath.indexOf(file+";") == -1) {
            try {
                System.setProperty("java.class.path", classpath + ";" + file +";");
                } catch (SecurityException e) {
                JOptionPane.showMessageDialog(null, 
                    "You dont have security permissions", 
                    "Alert", JOptionPane.ERROR_MESSAGE);
            } catch (Exception finalex) {
                JOptionPane.showMessageDialog(null, "Fatal Error", 
                    "Alert", JOptionPane.ERROR_MESSAGE);
            }
        } else
            JOptionPane.showMessageDialog(null, 
                "Classpath already set to the specified place", 
                "Alert", JOptionPane.ERROR_MESSAGE);
            System.out.println(System.getProperty("java.class.path"));
    }

    JPanel basepanel,formpanel;
    JScrollPane pane;
    JTextField text;
    DefaultMutableTreeNode top;
}

Code tags added by Michael Morris.
Overly long lines fixed by Jim Yingst.
[ January 20, 2004: Message edited by: Jim Yingst ]

[Michael Morris]

Hi Pinjalim, welcome to JavaRanch and the crazy world of ClassLoaders and CLASSPATHs. Even though you dynamically change the CLASSPATH, the problem is that the ClassLoader(s) idea of the CLASSPATH does not change so it is unable to find or resolve a class or dependent class outside of its notion of the CLASSPATH. You could try writing your own ClassLoader to overcome this problem, but aside from that, I don't think you will have much luck.

[David O'Meara]

You don't have to write your own ClassLoader, but you will have to create your own instance of a ClassLoader. THis ClassLoader will know about the extra Class location and will be able to load and return the Class.
I have some sample code for this, I'll have a look for it...

[David O'Meara]

I had to edit the sample. the code I had did something else entirely. It may not work without some

package com.javaranch.davo.classloader.sample;
import java.net.URL;
import java.net.URLClassLoader;
public class WhichClassLoader
{
    public static void main(String[] arg) throws Exception
    {
        //create two ClassLoaders with different
        URL[] classpathExt = { new File("dir1/").toURL() };
        URLClassLoader loader = new URLClassLoader( classpathExt, null );
        Class loadedClass = Class.forName("con.classto.Load", true, loader);
    }
}

This code adds the URL to the Class location, then it creates a ClassLOader that knows where this location is, then it uses that ClassLoader to load the CLass in that location.
Hope this is what you were looking for.
Dave.

[Stan James]

Here's a solution using reflection to get to protected features of the class loader. Probably not something to bet your career on:

public class ClassPathHacker {
    private static final Class[] parameters = new Class[]{URL.class};
    public static void addFile(String s) throws IOException {
File f = new File(s);
addFile(f);
    }//endmethod
    public static void addFile(File f) throws IOException {
addURL(f.toURL());
    }//end method
    public static void addURL(URL u) throws IOException {
        URLClassLoader sysloader = (URLClassLoader)ClassLoader.getSystemClassLoader();
Class sysclass = URLClassLoader.class;
try {
Method method = sysclass.getDeclaredMethod("addURL",parameters);
method.setAccessible(true);
method.invoke(sysloader,new Object[]{ u });
} catch (Throwable t) {
t.printStackTrace();
throw new IOException("Error, could not add URL to system classloader");
}//end try catch
    }//end method
}//end class

From : http://forum.java.sun.com/thread.jsp?forum=32&thread=300557&message=1191210
[ January 19, 2004: Message edited by: Michael Morris ]

[Michael Morris]

This code adds the URL to the Class location, then it creates a ClassLOader that knows where this location is, then it uses that ClassLoader to load the CLass in that location.

You could still throw a ClassNotFoundException if the class you are attempting to load is dependent on a class loaded by some other ClassLoader that your URLClassLoader knows nothing about.

[Michael Morris]

Oops. Actually you won't get a ClassNotFoundException, but if you try to call newInstance on the loaded class you can get a NoClassDefFoundError. Try this:
Put this in the ClassLoaderTests directory:

package test.classloader;
public class SomeUselessClass
{
    private int val;
    public SomeUselessClass()
    {
        this(0);
    }
    public SomeUselessClass(int val)
    {
        this.val = val;
    }
    public int getVal()
    {
        return val;
    }
    public void setVal(int val)
    {
        this.val = val;
    }
}

Put this in the ClassLoaderTests2 directory:

package test.dynamic;
import test.classloader.SomeUselessClass;
public class AnotherUselessClass
{
    private SomeUselessClass cls;
    public AnotherUselessClass()
    {
        this(0);
    }
    public AnotherUselessClass(int val)
    {
        this(new SomeUselessClass(val));
    }
    public AnotherUselessClass(SomeUselessClass cls)
    {
        this.cls = cls;
    }
    public int getVal()
    {
        return cls.getVal();
    }
    public void setVal(int val)
    {
        cls.setVal(val);
    }
}

Put this in the TestMain directory:

import java.net.URL;
import java.net.URLClassLoader;
import java.io.File;

public class TestClassLoader
{
    public static void main(String[] args) throws Exception
    {
        URL[] classpathExt = { new File("/ClassLoaderTests/").toURL() };
        URLClassLoader loader = new URLClassLoader(classpathExt, null );
        Class loadedClass = Class.forName("test.classloader.SomeUselessClass", true, loader);
        System.out.println(loadedClass);
        URL[] classpathExt2 = { new File("/ClassLoaderTests2/").toURL() };
        ClassLoader loader2 = new URLClassLoader(classpathExt2, null );
        Class loadedClass2 = Class.forName("test.dynamic.AnotherUselessClass", true, loader2);
        System.out.println(loadedClass2);
        loadedClass2.newInstance();
    }
}

The results should be something like this:

class test.classloader.SomeUselessClass
class test.dynamic.AnotherUselessClass
Exception in thread "main" java.lang.NoClassDefFoundError: test/classloader/SomeUselessClass
        at java.lang.Class.getDeclaredConstructors0(Native Method)
        at java.lang.Class.privateGetDeclaredConstructors(Class.java:1610)
        at java.lang.Class.getConstructor0(Class.java:1922)
        at java.lang.Class.newInstance0(Class.java:278)
        at java.lang.Class.newInstance(Class.java:261)
        at TestClassLoader.main(TestClassLoader.java:20)

[David O'Meara]

True, I was assuming there was just the default loader and the URLClassLoader. In my case, the added path would only be able to see itself and the 'java.**' classes. But in your case, you would include 'ClassLoaderTests' and 'ClassLoaderTests2' in the same ClassLoader and it should work fine.

public class TestClassLoader
{
    public static void main(String[] args) throws Exception
    {
        URL[] classpathExt = { 
          new File("/ClassLoaderTests/").toURL(), 
          new File("/ClassLoaderTests2/").toURL() 
          };
        URLClassLoader loader = new URLClassLoader(classpathExt, null );
        Class loadedClass = Class.forName("test.classloader.SomeUselessClass", true, loader);
        System.out.println(loadedClass);
        Class loadedClass2 = Class.forName("test.dynamic.AnotherUselessClass", true, loader);
        System.out.println(loadedClass2);
        loadedClass2.newInstance();
    }
}