New Java, old CORBA

[Tim Holloway]

I've got an app that was written before CORBA was integrated into the JDK (Java 1.18). It uses the Visigenic vbroker CORBA kit, but some of the methods in their org.omg classes didn't make it into standard Java.

What's the easiest way to get this ancient code to operate in a Java 1.5 or 1.6 JVM? I don't have a copy of Visigenics conversion tools.

[Nitesh Kant]

Tim:
What's the easiest way to get this ancient code to operate in a Java 1.5 or 1.6 JVM?

Will I be wrong in assuming that java 1.5 will be backward compatible with 1.18(There will be a lot of warnings probably, but it must work)

If the package is the same then probably, you have to go with a custom classloader searching its own classpath first before going to the parent.

P.S.: I have not worked on Visigenic vbroker CORBA kit and the above is just considering that it is any other third party library.

[Tim Holloway]

I can use compiler source level 1.3 and get by. My problem is that the org.omg classes defined by Sun don't contain some of the methods that the org.omg classes defined by Visigenic do.

Since Java 1.2, the org.omg package has been supplied integral to the JVM, so I'd need to either convert the Visigenic generated code or force an override to the JVM internal packages

[Nitesh Kant]

Tim:
I'd need to either convert the Visigenic generated code or force an override to the JVM internal packages

I think forcing an override of the JVM internal packages can be done by using a custom class loader. Sometime back i wrote the following:

  
 
import java.io.File;
import java.io.FilenameFilter;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
 
/**
 * This class loader will load classes on the basis of a pre-defined directory structure which is as
 * follows:
 * <PRE>
 -- <root>
        |
        -- classes
            |
            -- Implementation Classes
        -- lib
            |
            -- All external jar files.
    -- descriptor.xml
 * </PRE>
 * The classpath will contain the classes folder and all the jars under the lib folder.
 *
 * @author: Nitesh Kant
 */
public class CustomClassLoader extends URLClassLoader {
 
    private static final String LIBRARY_DIR_NAME = "lib";
    private static final String CLASSES_DIR_NAME = "classes";
    private ClassLoader parent;
    private boolean selfFirst;
 
    private String[] restrictedPkgs = new String[]{"java.", "javax."};
 
    private CustomClassLoader(URL[] classpath, ClassLoader parent, boolean selfFirst) {
        super(classpath, parent);
        this.parent = parent;
        this.selfFirst = selfFirst;
    }
 
    /**
     * Creates a class loader with the following entires in the classpath:
     * <ul>
     *   <li>Classes directory</li>
     *   <li>All jar files under the "lib" directory</li>
     * </ul>
     *
     * @param rootDir Root directory for the classes and libraries.
     * @param parent Parent class loader
     * @throws MalformedURLException If there is an error while creating the class loader.
     * @return An instance of the CustomClassLoader with appropriate classpath entires.
     */
    static CustomClassLoader getNewInstance(File rootDir, ClassLoader parent)
            throws MalformedURLException {
        return getNewInstance(rootDir, parent, false);
    }
 
    /**
     * Creates a class loader with the following entires in the classpath:
     * <ul>
     *   <li>Classes directory</li>
     *   <li>All jar files under the "lib" directory</li>
     * </ul>
     * Additionally this method can also specify whether the classes/resources loaded by this loader will first
     * search in this loaders classpath or its parent.<p>
     * This will help in situations where a module wants to use a library that is also present in the framework
     * but with a different version. However, framework specific classes are always loaded by the parent classloader.
     *
     * @param rootDir Root directory for the classes and libraries.
     * @param parent Parent class loader
     * @param selfFirst If the classloading mechanism looks for classes/resources in this loader classpath first.
     *
     * @throws MalformedURLException If there is an error while creating the class loader.
     * @return An instance of the CustomClassLoader with appropriate classpath entires.
     */
    static CustomClassLoader getNewInstance(File rootDir, ClassLoader parent, boolean selfFirst)
            throws MalformedURLException {
        URL[] classpath = getClassPath(rootDir);
        return new CustomClassLoader(classpath, parent, selfFirst);
    }
 
    @Override
    protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
 
        Class<?> toLoad;
 
        if (!selfFirst || isRestricted(name)) {
            try {
                toLoad = parent.loadClass(name);
            } catch (ClassNotFoundException e) {
                toLoad = loadClassSelfOnly(name);
            }
        } else {
            toLoad = loadClassSelfFirst(name);
        }
 
        if (resolve) {
            resolveClass(toLoad);
        }
        return toLoad;
    }
 
    @Override
    public URL findResource(final String name) {
        if (!selfFirst || isRestricted(name)) {
            return parent.getResource(name);
        }
        URL url = super.findResource(name);
        if (url == null) {
            url = parent.getResource(name);
        }
        return url;
    }
 
    ///////////////////////// Private Methods ///////////////////////////////
 
    /**
     * Creates URLs for the classpath. Following entires are added in the classpath:
     * <ul>
     *   <li>Classes directory</li>
     *   <li>All jar files under the "lib" directory</li>
     * </ul>
     *
     * @param rootDir  Root directory for the classes and libraries.
     * @return All URLs representing classpath entires.
     * @throws MalformedURLException If the URLS could not be created.
     */
    private static URL[] getClassPath(File rootDir)
            throws MalformedURLException {
        File libDir = new File(rootDir, LIBRARY_DIR_NAME);
        // Adding all the jar files present in the lib directory individually.
        File[] jarFiles = libDir.listFiles(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                return name.endsWith(".jar");
            }
        });
        List<URL> classpathElements = new ArrayList<URL>();
        // Adding the lib directory itself so that any other file except for jar files are added to the classpath
        classpathElements.add(toUrl(libDir));
        if(null != jarFiles) {
            for (File jarFile : jarFiles) {
                classpathElements.add(toUrl(jarFile));
            }
        }
        File classesDir = new File(rootDir, CLASSES_DIR_NAME);
        classpathElements.add(toUrl(classesDir));
        URL[] urls = new URL[classpathElements.size()];
        return classpathElements.toArray(urls);
    }
 
    /**
     * Converts the passed classpath entry to a URL.
     *
     * @param classpathEntry entry to convert to a URL.
     * @return A URL for the passed entry.
     *
     * @throws MalformedURLException Malformed classpath entry url.
     */
    private static URL toUrl(File classpathEntry) throws MalformedURLException {
        return classpathEntry.toURI().toURL();
    }
 
    private boolean isRestricted(String name) {
        if (name == null) {
            return true;
        }
        for (String filteredPkg : restrictedPkgs) {
            if (name.startsWith(filteredPkg)) {
                return true;
            }
        }
        return false;
    }
 
    private Class loadClassSelfFirst(String name) throws ClassNotFoundException {
        Class c;
        try {
            c = loadClassSelfOnly(name);
        } catch (ClassNotFoundException e) {
            // If not found, then invoke loadClass of parent to find the class.
            c = parent.loadClass(name);
        }
        return c;
    }
 
    private Class loadClassSelfOnly(String name) throws ClassNotFoundException {
        // First, check if the class has already been loaded
        Class c = findLoadedClass(name);
        if (c == null) {
            c = findClass(name);
        }
        return c;
    }
}

This classloader if created with selfFirst true, will load the classes using its own classpath first.
It may be of help to you.