面试题：能否自定义一个java.lang.Object类

创建自定义的java.lang.Object

首先尝试在工程中创建自己的java.lang.Object类：

package java.lang;

/**
 * 自己创建的java.lang.Object
 *
 * @author hujy
 * @version 1.0
 * @date 2020-01-30 01:12
 */
public class Object {
    static {
        System.out.println("hello");
    }
    public static void main(String[] args) {
        Object o = new Object();
    }
}

运行main方法，发现打印报错：

我们知道，类加载的过程会遵循双亲委派原则，当一个类首次被加载时，会依次向上级类加载器委托， 直到最顶层的BootstrapClassLoader。java.lang.Object属于系统类，会由BootstrapClassLoader优先加载，最终加载的还是系统原生的java.lang.Object类，因此会报找不到main方法的错误。

---

创建自定义类加载器

有了这一前提，我们需要通过自定义类加载器绕过双亲委派机制，实现自定义类的加载。

MyClassLoader为自定义类加载器，它继承于ClassLoader，覆写了loadClass方法，实现自定义加载。

package com.hujy.classloader;

import java.io.IOException;
import java.io.InputStream;

/**
 * 自定义类加载器
 *
 * @author hujy
 * @date 2020-01-30 00:56
 */
public class MyClassLoader extends ClassLoader {

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (name == null || "".equals(name)) {
            throw new ClassNotFoundException();
        }
        InputStream is = null;
        try {
            String className = "/" + name.replace('.', '/') + ".class";
            System.out.println(className);
            // 在classpath路径下加载java/lang/Object.class文件
            is = getClass().getResourceAsStream(className);
            System.out.println(is);
            if (is == null) {
                throw new ClassNotFoundException();
            }
            byte[] bytes = new byte[is.available()];
            is.read(bytes);
            // 调用父类classLoader的defineClass方法
            // 将字节数组转换为Class实例
            return defineClass(name, bytes, 0, bytes.length);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyClassLoader myClassLoader = new MyClassLoader();
        try {
            Class<?> clazz = Class.forName("java.lang.Object", true, myClassLoader);
            System.out.println("自定义类加载器：" + clazz.newInstance().getClass().getClassLoader());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行main函数：

提示：禁止使用包名：“java.lang”。

跟进defineClass的源码：

    protected final Class<?> defineClass(String name, byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(name, b, off, len, null);
    }

    /* Determine protection domain, and check that:
        - not define java.* class,
        - signer of this class matches signers for the rest of the classes in
          package.
    */
    private ProtectionDomain preDefineClass(String name,
                                            ProtectionDomain pd)
    {
        if (!checkName(name))
            throw new NoClassDefFoundError("IllegalName: " + name);

        // Note:  Checking logic in java.lang.invoke.MemberName.checkForTypeAlias
        // relies on the fact that spoofing is impossible if a class has a name
        // of the form "java.*"
        if ((name != null) && name.startsWith("java.")) {
            throw new SecurityException
                ("Prohibited package name: " +
                 name.substring(0, name.lastIndexOf('.')));
        }
        if (pd == null) {
            pd = defaultDomain;
        }

        if (name != null) checkCerts(name, pd.getCodeSource());

        return pd;
    }

在defineClass的逻辑中是禁止包以“java.”开头命名的，并且该方法为final方法，禁止覆写，说明了我们无法通过自定义类加载器加载以“java.”开头的类。

我们将自定义java.lang.Object修改成myjava.lang.Object，再对自定义类加载器中loadClass方法做一下修改：以“java.”开头的类交给父加载器加载。

public class MyClassLoader extends ClassLoader {

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (name == null || "".equals(name)) {
            throw new ClassNotFoundException();
        } else if (name.startsWith("java.")) {
            // 由父类加载java.开头的类
            return super.loadClass(name);
        }
        InputStream is = null;
        try {
            String className = "/" + name.replace('.', '/') + ".class";
            System.out.println(className);
            // 在classpath路径下加载java/lang/Object.class文件
            is = getClass().getResourceAsStream(className);
            System.out.println(is);
            if (is == null) {
                throw new ClassNotFoundException();
            }
            byte[] bytes = new byte[is.available()];
            is.read(bytes);
            // 调用父类classLoader的defineClass方法
            // 将字节数组转换为Class实例
            return defineClass(name, bytes, 0, bytes.length);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyClassLoader myClassLoader = new MyClassLoader();
        try {
            Class<?> clazz = Class.forName("myjava.lang.Object", true, myClassLoader);
            System.out.println("自定义类加载器：" + clazz.newInstance().getClass().getClassLoader());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

再次运行main方法：

---

总结

• 正常情况下类加载过程会遵循双亲委派机制，依次向上级类加载器委托加载，上级都加载不了，才会自行加载。
• 如果想绕过双亲委派机制，需要覆写ClassLoader类的loadClass方法，一般不推荐这么做。
• 由于final方法defineClass的限制，我们无法加载以“java.”开头的系统类。
• 一般自定义类加载器只需实现ClassLoader的findClass方法来加载自定义路径下的类，而不是覆写loadClass破坏双亲委派，避免带来系统安全隐患。