ClassLoader

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.apache.bcel.util;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Hashtable;

import org.apache.bcel.Const;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.ConstantClass;
import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.classfile.ConstantUtf8;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Utility;

/**
 * <p>
 * Drop in replacement for the standard class loader of the JVM. You can use it in conjunction with the JavaWrapper to
 * dynamically modify/create classes as they're requested.
 * </p>
 *
 * <p>
 * This class loader recognizes special requests in a distinct format, i.e., when the name of the requested class
 * contains with "$$BCEL$$" it calls the createClass() method with that name (everything bevor the $$BCEL$$ is
 * considered to be the package name. You can subclass the class loader and override that method. "Normal" classes class
 * can be modified by overriding the modifyClass() method which is called just before defineClass().
 * </p>
 *
 * <p>
 * There may be a number of packages where you have to use the default class loader (which may also be faster). You can
 * define the set of packages where to use the system class loader in the constructor. The default value contains
 * "java.", "sun.", "javax."
 * </p>
 *
 * @see JavaWrapper
 * @see ClassPath
 * @deprecated 6.0 Do not use - does not work
 */
@Deprecated
public class ClassLoader extends java.lang.ClassLoader {

    private static final String BCEL_TOKEN = "$$BCEL$$";

    public static final String[] DEFAULT_IGNORED_PACKAGES = {"java.", "javax.", "sun."};

    private final Hashtable<String, Class<?>> classes = new Hashtable<>();
    // Hashtable is synchronized thus thread-safe
    private final String[] ignoredPackages;
    private Repository repository = SyntheticRepository.getInstance();

    /**
     * Ignored packages are by default ( "java.", "sun.", "javax."), i.e. loaded by system class loader
     */
    public ClassLoader() {
        this(DEFAULT_IGNORED_PACKAGES);
    }

    /**
     * @param deferTo delegate class loader to use for ignored packages
     */
    public ClassLoader(final java.lang.ClassLoader deferTo) {
        super(deferTo);
        this.ignoredPackages = DEFAULT_IGNORED_PACKAGES;
        this.repository = new ClassLoaderRepository(deferTo);
    }

    /**
     * @param ignoredPackages classes contained in these packages will be loaded with the system class loader
     * @param deferTo delegate class loader to use for ignored packages
     */
    public ClassLoader(final java.lang.ClassLoader deferTo, final String[] ignoredPackages) {
        this(ignoredPackages);
        this.repository = new ClassLoaderRepository(deferTo);
    }

    /**
     * @param ignoredPackages classes contained in these packages will be loaded with the system class loader
     */
    public ClassLoader(final String[] ignoredPackages) {
        this.ignoredPackages = ignoredPackages;
    }

    /**
     * Override this method to create you own classes on the fly. The name contains the special token $$BCEL$$. Everything
     * before that token is considered to be a package name. You can encode your own arguments into the subsequent string.
     * You must ensure however not to use any "illegal" characters, i.e., characters that may not appear in a Java class
     * name too
     * <p>
     * The default implementation interprets the string as a encoded compressed Java class, unpacks and decodes it with the
     * Utility.decode() method, and parses the resulting byte array and returns the resulting JavaClass object.
     * </p>
     *
     * @param className compressed byte code with "$$BCEL$$" in it
     */
    protected JavaClass createClass(final String className) {
        final int index = className.indexOf(BCEL_TOKEN);
        final String realName = className.substring(index + BCEL_TOKEN.length());
        JavaClass clazz = null;
        try {
            final byte[] bytes = Utility.decode(realName, true);
            final ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes), "foo");
            clazz = parser.parse();
        } catch (final IOException e) {
            e.printStackTrace();
            return null;
        }
        // Adapt the class name to the passed value
        final ConstantPool cp = clazz.getConstantPool();
        final ConstantClass cl = cp.getConstant(clazz.getClassNameIndex(), Const.CONSTANT_Class, ConstantClass.class);
        final ConstantUtf8 name = cp.getConstantUtf8(cl.getNameIndex());
        name.setBytes(Utility.packageToPath(className));
        return clazz;
    }

    @Override
    protected Class<?> loadClass(final String className, final boolean resolve) throws ClassNotFoundException {
        Class<?> cl = null;
        /*
         * First try: lookup hash table.
         */
        if ((cl = classes.get(className)) == null) {
            /*
             * Second try: Load system class using system class loader. You better don't mess around with them.
             */
            for (final String ignoredPackage : ignoredPackages) {
                if (className.startsWith(ignoredPackage)) {
                    cl = getParent().loadClass(className);
                    break;
                }
            }
            if (cl == null) {
                JavaClass clazz = null;
                /*
                 * Third try: Special request?
                 */
                if (className.contains(BCEL_TOKEN)) {
                    clazz = createClass(className);
                } else { // Fourth try: Load classes via repository
                    if ((clazz = repository.loadClass(className)) == null) {
                        throw new ClassNotFoundException(className);
                    }
                    clazz = modifyClass(clazz);
                }
                if (clazz != null) {
                    final byte[] bytes = clazz.getBytes();
                    cl = defineClass(className, bytes, 0, bytes.length);
                } else {
                    cl = Class.forName(className);
                }
            }
            if (resolve) {
                resolveClass(cl);
            }
        }
        classes.put(className, cl);
        return cl;
    }

    /**
     * Override this method if you want to alter a class before it gets actually loaded. Does nothing by default.
     */
    protected JavaClass modifyClass(final JavaClass clazz) {
        return clazz;
    }
}