Java VM.getNonBootstrapClassLoader方法代码示例

import org.apache.harmony.kernel.vm.VM; //导入方法依赖的package包/类
/**
 * Creates the proxy class that implements the interfaces specified in
 * {@code interfaceNames}.
 * 
 * @param interfaceNames
 *            the interfaces used to create the proxy class.
 * @return the proxy class.
 * @throws ClassNotFoundException
 *             if the proxy class or any of the specified interfaces cannot
 *             be created.
 * @throws IOException
 *             if an error occurs while reading from the source stream.
 * @see ObjectOutputStream#annotateProxyClass(Class)
 */
protected Class<?> resolveProxyClass(String[] interfaceNames)
        throws IOException, ClassNotFoundException {
        
    // TODO: This method is opportunity for performance enhancement
    //       We can cache the classloader and recently used interfaces.        
    ClassLoader loader = VM.getNonBootstrapClassLoader();
    Class<?>[] interfaces = new Class<?>[interfaceNames.length];
    for (int i = 0; i < interfaceNames.length; i++) {
        interfaces[i] = Class.forName(interfaceNames[i], false, loader);
    }
    try {
        return Proxy.getProxyClass(loader, interfaces);
    } catch (IllegalArgumentException e) {
        throw new ClassNotFoundException(e.toString(), e);
    }
}
 

import org.apache.harmony.kernel.vm.VM; //导入方法依赖的package包/类
/**
 * Retrieves the proxy class corresponding to the interface names.
 * 
 * @param interfaceNames
 *            The interfaces used to create the proxy class
 * @return A proxy class
 * 
 * @throws IOException
 *             If any IO problem occurred when trying to load the class.
 * @throws ClassNotFoundException
 *             If the proxy class cannot be created
 */
protected Class<?> resolveProxyClass(String[] interfaceNames)
        throws IOException, ClassNotFoundException {
    ClassLoader loader = VM.getNonBootstrapClassLoader();
    Class<?>[] interfaces = new Class<?>[interfaceNames.length];
    for (int i = 0; i < interfaceNames.length; i++) {
        interfaces[i] = Class.forName(interfaceNames[i], false, loader);
    }
    try {
        return Proxy.getProxyClass(loader, interfaces);
    } catch (IllegalArgumentException e) {
        throw new ClassNotFoundException(e.toString(), e);
    }
}
 

import org.apache.harmony.kernel.vm.VM; //导入方法依赖的package包/类
private Object readObject(boolean unshared) throws OptionalDataException,
        ClassNotFoundException, IOException {
    boolean restoreInput = (primitiveData == input);
    if (restoreInput) {
        primitiveData = emptyStream;
    }

    // This is the spec'ed behavior in JDK 1.2. Very bizarre way to allow
    // behavior overriding.
    if (subclassOverridingImplementation && !unshared) {
        return readObjectOverride();
    }

    // If we still had primitive types to read, should we discard them
    // (reset the primitiveTypes stream) or leave as is, so that attempts to
    // read primitive types won't read 'past data' ???
    Object result;
    try {
        // We need this so we can tell when we are returning to the
        // original/outside caller
        if (++nestedLevels == 1) {
            // Remember the caller's class loader
            callerClassLoader = VM.getNonBootstrapClassLoader();
        }

        result = readNonPrimitiveContent(unshared);
        if (restoreInput) {
            primitiveData = input;
        }
    } finally {
        // We need this so we can tell when we are returning to the
        // original/outside caller
        if (--nestedLevels == 0) {
            // We are going to return to the original caller, perform
            // cleanups.
            // No more need to remember the caller's class loader
            callerClassLoader = null;
        }
    }

    // Done reading this object. Is it time to return to the original
    // caller? If so we need to perform validations first.
    if (nestedLevels == 0 && validations != null) {
        // We are going to return to the original caller. If validation is
        // enabled we need to run them now and then cleanup the validation
        // collection
        try {
            for (InputValidationDesc element : validations) {
                element.validator.validateObject();
            }
        } finally {
            // Validations have to be renewed, since they are only called
            // from readObject
            validations = null;
        }
    }
    return result;
}