/**
 * 目标类和代理类共同实现的接口
 **/
public interface Flyable {
    void fly(String param);
}

/**
 * 目标类
 **/
@Slf4j
public class Bird implements Flyable {
    @Override
    public void fly(String param) {
        log.info("Target bird fly, param = {}", param);
    }
}

/**
 * 代理类
 **/
@Slf4j
@AllArgsConstructor
public class BirdProxy implements InvocationHandler {

    // 目标对象
    private Flyable target;

    // proxy 参数表示动态生成的 Proxy 类 通过反射创建出来的对象
    // method 参数表示 proxy 对象本次执行的方法，可以判断该参数动态决定执行对应的业务逻辑
    // args 参数表示 proxy 对方本次执行的方法参数
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在目标对象执行前执行代码
        log.info("Before target bird method: {}", method.getName());
        // 在目标对象上执行指定方法
        Object result = method.invoke(target, args);
        // 在目标对象执行后执行代码
        log.info("After target bird method: {}", method.getName());
        return result;
    }

    // 创建代理对象
    public static Flyable newProxy(Flyable target) {
        // 方式一：显式使用反射创建代理对象（先获取 com.sun.proxy.$Proxy0 的 Class 对象）
        // Class<?> proxyClass = Proxy.getProxyClass(Flyable.class.getClassLoader(), target.getClass().getInterfaces());
        // Constructor<?> constructor = proxyClass.getConstructor(InvocationHandler.class);
        // return (Flyable) constructor.newInstance(new BirdProxy(target));
        
        // 方式二：隐式使用反射创建代理对象，API 更简单
        return (Flyable) Proxy.newProxyInstance(Flyable.class.getClassLoader(), target.getClass().getInterfaces(), new BirdProxy(target));
    }

}

@Slf4j
public class FlyTest {

    @Test
    public void test() {
        // 创建目标对象
        Bird target = new Bird();
        // 创建代理对象
        Flyable proxy = BirdProxy.newProxy(target);
        // 调用任意方法，将执行代理逻辑
        proxy.fly("hello world");
    }
}

Before target bird method: fly
Target bird fly, param = hello world
After target bird method: fly

public class Proxy implements java.io.Serializable {

    /** 代理类构造方法的参数类型 */
    private static final Class<?>[] constructorParams = { InvocationHandler.class };

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * 查找或生成指定的代理类
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * 反射调用代理类的构造方法（入参为指定的 invocation handler）创建实例
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            // 反射获取构造方法
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // 调用构造方法，创建代理对象
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

    /**
     * Generate a proxy class.  Must call the checkProxyAccess method
     * to perform permission checks before calling this.
     */
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }
}

package com.sun.proxy;

import com.github.proxy.Flyable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Flyable {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void fly(String var1) throws  {
        try {
            // 调用 proxy 对象的 fly 方法，则委托 InvocationHandler 对象执行 invoke 方法
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.github.proxy.Flyable").getMethod("fly", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

TypeVariable<?>[] getTypeParameters()

public interface BaseMapper<T extends Serializable & Comparable<T>, K extends Serializable> {

    T getById(K id);

}

public class PersonMapper implements BaseMapper<Person, Long>, Serializable {
    @Override
    public Person getById(Long id) {
        return null;
    }

    public void log(List<?> list) {

    }

    public <T extends Number> void test(List<T> list1, List<? extends Comparable<T>> list2, T[] array, T item) {
    }
}

public class Person implements Serializable, Comparable<Person> {
    private String personName;

    @Override
    public int compareTo(Person o) {
        return this.personName.compareTo(o.getPersonName());
    }

@Test
public void test1() {
    Method method = PersonMapper.class.getMethod("test", List.class, List.class, Number[].class, Number.class);

    // [0] ParameterizedType
    // [1] ParameterizedType
    // [2] GenericArrayType
    // [3] TypeVariable
    Type[] genericParameterTypes = method.getGenericParameterTypes();
    
    // Class
    Type genericReturnType = method.getGenericReturnType();
    
    // Class[0]
    Type[] genericExceptionTypes = method.getGenericExceptionTypes();
}

@Test
public void test2() {
    // com.github.reflection.BaseMapper<com.github.reflection.Person, java.lang.Long>
    Type genericInterface = PersonMapper.class.getGenericInterfaces()[0];
    assertTrue(genericInterface instanceof ParameterizedType);
    ParameterizedType parameterizedType = (ParameterizedType) genericInterface;
    
    // 获取原始类型：BaseMapper.class
    assertEquals(BaseMapper.class, parameterizedType.getRawType());

    // 获取实际类型参数列表：Person.class、Long.class
    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    assertEquals("There are two actual type arguments", 2, actualTypeArguments.length);
    // class com.github.reflection.Person
    assertClass("One is Person", actualTypeArguments[0], Person.class);
    // class java.lang.Long
    assertClass("Another is Long", actualTypeArguments[1], Long.class);
}

private void assertClass(Type type, Class expectedClass) {
    assertTrue(type instanceof Class);
    Class clazz = (Class) type;
    assertEquals(expectedClass, clazz);
}

@Test
public void test3() {
    // java.util.List<?>
    Method method = PersonMapper.class.getMethod("log", List.class);
    Type genericParameterType = method.getGenericParameterTypes()[0];
    assertTrue("The first parameter type of log method is instance of ParameterizedType", 
               genericParameterType instanceof ParameterizedType);
    ParameterizedType parameterType = (ParameterizedType) genericParameterType;

    // WildcardType
    Type type = parameterType.getActualTypeArguments()[0];
    assertTrue("The actual type argument of ParameterizedType is instance of WildcardType", 
               type instanceof WildcardType);
    WildcardType wildcardType = (WildcardType) type;
    assertEquals("No lower bounds exist", 0, wildcardType.getLowerBounds().length);
    assertEquals("Only one upper bound exist", 1, wildcardType.getUpperBounds().length);
    // 通配符默认上限类型为 Object
    assertEquals("The upper bound is Object", Object.class, wildcardType.getUpperBounds()[0]);
}

@Test
public void test4() {
    Method method = BaseMapper.class.getMethod("getById", Serializable.class);

    // TypeVariable
    Type genericReturnType = method.getGenericReturnType();
    assertTrue("Return type of method is instance of TypeVariable", genericReturnType instanceof TypeVariable);
    TypeVariable typeVariable = (TypeVariable) genericReturnType;
    assertEquals("First upper bound is Serializable", Serializable.class, typeVariable.getBounds()[0]);
    ParameterizedType parameterizedType = (ParameterizedType) typeVariable.getBounds()[1];
    assertEquals("Second upper bound is Comparable", Comparable.class, parameterizedType.getRawType());
}

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
 
public class GenericsUtils {
    /**
     * 通过反射获得定义 Class 时声明的父类的泛型参数的类型
     * @param clazz 
     * @return 返回第一个类型
     */
    public static Class getSuperClassGenricType(Class clazz) {
        return getSuperClassGenricType(clazz, 0);
    }
 
    /**
     * 通过反射获得定义 Class 时声明的父类的泛型参数的类型
     * @param clazz
     * @param 返回某个下标的类型
     */
    public static Class getSuperClassGenricType(Class clazz, int index)
            throws IndexOutOfBoundsException {
        Type genType = clazz.getGenericSuperclass();
        if (!(genType instanceof ParameterizedType)) {
            return Object.class;
        }
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        if (index >= params.length || index < 0) {
            return Object.class;
        }
        if (!(params[index] instanceof Class)) {
            return Object.class;
        }
        return (Class) params[index];
    }
}

@Native
@Documented
@Inherited
@Repeatable
@Target
@Retention

/**
* Annotation retention policy.  The constants of this enumerated type
* describe the various policies for retaining annotations.  They are used
* in conjunction with the {@link Retention} meta-annotation type to specify
* how long annotations are to be retained.
*
* @author  Joshua Bloch
* @since 1.5
*/
public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

// 判断某个注解是否存在
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
// 获取注解（包括父类）
<T extends Annotation> T getAnnotation(Class<T>)
<T extends Annotation> T[] getAnnotationsByType(Class<T>)
Annotation[] getAnnotations()
// 获取注解（不包括父类）
<T extends Annotation> T getDeclaredAnnotation(Class<T>)
<T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T>)
Annotation[] getDeclaredAnnotations()

java.lang.Class
java.lang.Package
java.lang.reflect.Field
java.lang.reflect.Method
java.lang.reflect.Constructor
java.lang.reflect.Parameter

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface Check {}

@Check
public class Person {
    @Check
    public void say() {}

    @Check
    public void say(String msg) {}
}

@ToString
public class Child extends Person {
    public String childName = "Hello";
    
    @Override
    public void say() {}
}

public class Test {
    @Test
    public void test() {
        ToString annotation = Child.class.getAnnotation(ToString.class);
        assertNull("结果为 null 因为 @ToString 标注为 @Retention(RetentionPolicy.SOURCE)", annotation);

        Check annotation1 = Child.class.getAnnotation(Check.class);
        assertNotNull("结果不为 null 因为 @Check 标注为 @Retention(RetentionPolicy.RUNTIME)、@Inherited 并且 @Check 被标注在父类上，可以被子类继承", annotation1);

        Check annotation2 = Child.class.getDeclaredAnnotation(Check.class);
        assertNull("结果为 null 因为 getDeclaredAnnotation 方法无法拿到父类注解", annotation2);

        Method sayString = Child.class.getMethod("say", String.class);
        Check annotation3 = sayString.getAnnotation(Check.class);
        assertNotNull("结果不为 null 因为 say 方法未被子类重写，被完整继承下来", annotation3);

        Method say = Child.class.getMethod("say");
        Check annotation4 = say.getAnnotation(Check.class);
        assertNull("结果为 null 因为 say 方法被子类重写了", annotation4);
    }
}

@Check
public interface Sayable {
    @Check
    void say();
}

public class Student implements Sayable {
    @Override
    public void say() {}
}

public class Test {
    @Test
    public void test() {
        Check annotation5 = Student.class.getAnnotation(Check.class);
        assertNull("结果为 null 因为接口上的注解无法被子类继承", annotation5);

        Check annotation6 = Student.class.getMethod("say").getAnnotation(Check.class);
        assertNull("结果为 null", annotation6);
    }
}

java.lang.Class
java.lang.Package
java.lang.reflect.Field
java.lang.reflect.Method
java.lang.reflect.Constructor
// JDK 1.8 新引入，通过该类的 getName 方法能在运行时得到参数的名称（前提是通过 -parameters 指定编译器在编译的时候将参数名编译进去）
java.lang.reflect.Parameter

java.lang.reflect.Array

// 方法一：直接通过一个 class 的静态变量 class 获取
Class<String> aClass = String.class;

// 方法二：通过实例变量提供的 getClass() 方法获取
Class<? extends String> aClass2 = "Hello".getClass();

// 方法三：通过 class 的完整类名获取，底层调用的是应用类加载器 Application ClassLoader (sun.misc.Launcher$AppClassLoader)
Class<?> aClass3 = Class.forName("java.lang.String");

// 方法四：通过自定义 ClassLoader 获取
URLClassLoader classLoader = new URLClassLoader(new URL[] {new URL("file:/c:/")});
Class<?> aClass4 = classLoader.loadClass("java.lang.String");

// 获取父类
Class<? super String> superclass = String.class.getSuperclass();  // class java.lang.Object
// 获取外部类
Class<?> enclosingClass = Map.Entry.class.getEnclosingClass();  // interface java.util.Map
// 获取内部类
Class<?>[] classes = HashMap.class.getClasses();  // 2 个内部类
Class<?>[] declaredClasses = HashMap.class.getDeclaredClasses();  // 13 个内部类

// true
assertTrue(aClass == aClass2);
assertTrue(aClass == aClass3);
assertTrue(aClass2 == aClass3);

// 字段名称
String getName()
// 字段类型
Class<?> getType()
// 字段的修饰符，返回值是一个int，不同的 bit 表示不同的含义。使用 Modifier 工具类进行解析
int getModifiers()

public final class String {
    private final byte[] value;
}

Field f = String.class.getDeclaredField("value");
f.getName(); // "value"
f.getType(); // class [B 表示byte[]类型
int m = f.getModifiers();
Modifier.isFinal(m); // true
Modifier.isPublic(m); // false
Modifier.isProtected(m); // false
Modifier.isPrivate(m); // true
Modifier.isStatic(m); // false

// 获取字段值
Object get(Object obj)
boolean getBoolean(Object obj)
byte getByte(Object obj)
char getChar(Object obj)
short getShort(Object obj)
int getInt(Object obj)
long getLong(Object obj)
float getFloat(Object obj)
double getDouble(Object obj)

// 设置字段值
void set(Object obj, Object value)
void setBoolean(Object obj, boolean z)
void setByte(Object obj, byte b)
void setChar(Object obj, char c)
void setShort(Object obj, short s)
void setInt(Object obj, int i)
void setLong(Object obj, long l)
void setFloat(Object obj, float f)
void setDouble(Object obj, double d)

// 方法名称
String getName()
// 方法参数个数
int getParameterCount()
// 方法参数类型
Class<?>[] getParameterTypes()
// 方法参数注解
Annotation[][] getParameterAnnotations()
// 方法返回值类型
Class<?> getReturnType()
// 方法异常类型
Class<?>[] getExceptionTypes()
// 方法的修饰符，返回值是一个int，不同的 bit 表示不同的含义。使用 Modifier 工具类进行解析
int getModifiers()

// 第一个参数为指定的实例对象。
// 如果是静态方法，可传 null。
// 如果是非 public 方法，需先设置 setAccessible(true)
Object invoke(Object obj, Object... args)

// 方式一：通过 new 操作符
Person p = new Person();

// 方式二：通过反射，调用 Class 提供的 newInstance() 方法。局限是只能调用其 public 无参构造方法
Person p = Person.class.newInstance();

// 方式三：通过反射，调用 Constructor 提供的 newInstance() 方法。如果是非 public 方法，需先设置 setAccessible(true)
// 这里通过 private Person(String name) 构造新实例
Constructor<Person> constructor = Person.class.getDeclaredConstructor(String.class);
constructor.setAccessible(true);
Person peter = constructor.newInstance("Peter");

// 获取父类（Object 的父类是 null，其他任何非 interface 的 Class 都必定存在一个父类类型）
Class<? super T> getSuperclass()

// 获取已实现接口（只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型）
Class<?>[] getInterfaces()

Object n = Integer.valueOf(123);
boolean isDouble = n instanceof Double; // false
boolean isInteger = n instanceof Integer; // true
boolean isNumber = n instanceof Number; // true
boolean isSerializable = n instanceof java.io.Serializable; // true

boolean isDouble = Double.class.isInstance(n); // false

Number num1 = (Number) n;
Number num2 = Number.class.cast(n);

Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object
Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer

ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
while(driversIterator.hasNext()) {
    Driver driver = driversIterator.next();
}

public final class ServiceLoader<S>
    implements Iterable<S>
{

    // 类加载器加载配置文件时 所用的固定目录
    private static final String PREFIX = "META-INF/services/";

    // 代表被加载的类或者接口
    // The class or interface representing the service being loaded
    private final Class<S> service;

    // 用于定位，加载和实例化 providers 的类加载器
    // The class loader used to locate, load, and instantiate providers
    private final ClassLoader loader;

    // 创建 ServiceLoader 时采用的访问控制上下文
    // The access control context taken when the ServiceLoader is created
    private final AccessControlContext acc;

    // 缓存 providers，按实例化的顺序排列
    // Cached providers, in instantiation order
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // 懒查找迭代器
    // The current lazy-lookup iterator
    private LazyIterator lookupIterator;
}

    // Private inner class implementing fully-lazy provider lookup
    //
    private class LazyIterator
        implements Iterator<S>
    {

        Class<S> service;
        ClassLoader loader;
        Enumeration<URL> configs = null;
        Iterator<String> pending = null;
        String nextName = null;

        private boolean hasNextService() {
            if (nextName != null) {
                return true;
            }
            // 判断是否首次使用
            if (configs == null) {
                try {
                    // 本例中值为 META-INF/services/java.sql.Driver
                    String fullName = PREFIX + service.getName();
                    if (loader == null)
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                        // 使用类加载器从类路径中加载文件：META-INF/services/java.sql.Driver，如果多个 jar 包都存在该文件则结果为多个 URL 实例
                        configs = loader.getResources(fullName);
                } catch (IOException x) {
                    fail(service, "Error locating configuration files", x);
                }
            }
            while ((pending == null) || !pending.hasNext()) {
                if (!configs.hasMoreElements()) {
                    return false;
                }
                // 依次解析 URL，获取 URL 内容的迭代器
                pending = parse(service, configs.nextElement());
            }
            // 依次获取 URL 内容，例如第一条为 com.mysql.jdbc.Driver
            nextName = pending.next();
            return true;
        }

        private S nextService() {
            if (!hasNextService())
                throw new NoSuchElementException();
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
                // 使用指定的类加载器查找并加载类：com.mysql.jdbc.Driver
                c = Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) {
                fail(service,
                     "Provider " + cn + " not found");
            }
            if (!service.isAssignableFrom(c)) {
                fail(service,
                     "Provider " + cn  + " not a subtype");
            }
            try {
                // 通过反射，调用 com.mysql.jdbc.Driver 的 public 无参构造方法创建 Object 实例对象，并强制转换为 interface java.sql.Driver 类型
                S p = service.cast(c.newInstance());
                // 塞入缓存，key 为 com.mysql.jdbc.Driver 字符串，value 是对应的实例对象
                providers.put(cn, p);
                return p;
            } catch (Throwable x) {
                fail(service,
                     "Provider " + cn + " could not be instantiated",
                     x);
            }
            throw new Error();          // This cannot happen
        }

        ...

}

// Bootstrap ClassLoader
String property1 = System.getProperty("sun.boot.class.path");
// Extension ClassLoader
String property2 = System.getProperty("java.ext.dirs");
// Application ClassLoader
String property3 = System.getProperty("java.class.path");

public interface Flyable {
    void fly(String param);
}

public class Bird implements Flyable {
    @Override
    public void fly(String param) {}
}

public class Test {
    public static void main(String[] args) {
        System.out.println("===============");
        Bird bird = new Bird();
    }
}

public class Test {
    @Test
    public void test() {
        // 结果为 null，因为启动类加载器为 C++ 编写
        ClassLoader bootstrapClassLoader = java.lang.String.class.getClassLoader();
        // sun.misc.Launcher$ExtClassLoader
        ClassLoader extClassLoader = com.sun.crypto.provider.DESKeyFactory.class.getClassLoader();
        // sun.misc.Launcher$AppClassLoader
        ClassLoader appClassLoader = Test.class.getClassLoader();
    }
}

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // 首先，检查类是否已经被加载
        Class<?> c = findLoadedClass(name);
        // 未被加载的情况
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                // 如果父加载器不为 null，则委托父加载器去加载类
                if (parent != null) {
                    // 调用父加载器的 loadClass 方法，委托其去加载类
                    c = parent.loadClass(name, false);
                }
                // 如果父加载器为 null，则委托 Bootstrap ClassLoader 去加载类
                else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }

            // 如果父加载器都加载不到，则调用自身的 findClass 方法查找类
            if (c == null) {
                long t1 = System.nanoTime();
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        // 如果上述步骤找到了类，并且 resolve 标记为 true，则在目标 Class 对象上调用 resolveClass(Class) 方法，进入“连接（Linking）”阶段（详见官方文档）
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

Class<?> clazz = classLoader.loadClass("com.github.parent.HelloWorld");
Object instance = clazz.newInstance();

protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

// 从 E 盘中加载类文件
URLClassLoader classLoader = new URLClassLoader(new URL[] {new URL("file:/e:/")});
// 从 localhost 中加载类文件
// URLClassLoader classLoader = new URLClassLoader(new URL[] {new URL("http://localhost/testfile/")});
Class<?> clazz = classLoader.loadClass("com.github.parent.HelloWorld");
Object instance = clazz.newInstance();
// java.net.URLClassLoader
String name = instance.getClass().getClassLoader().getClass().getName();

protected Class<?> findClass(final String name)
    throws ClassNotFoundException
{
    final Class<?> result;
    try {
        result = AccessController.doPrivileged(
            new PrivilegedExceptionAction<Class<?>>() {
                public Class<?> run() throws ClassNotFoundException {
                    // 将二进制名称替换为文件路径（类似全限定名），例如：com.github.HelloWorld > com/github/HelloWorld.class
                    String path = name.replace('.', '/').concat(".class");
                    // 从 URLClassPath 对象中查找文件
                    Resource res = ucp.getResource(path, false);
                    if (res != null) {
                        try {
                            // 如果找到文件，则构造为 Class 类实例
                            return defineClass(name, res);
                        } catch (IOException e) {
                            throw new ClassNotFoundException(name, e);
                        }
                    } else {
                        return null;
                    }
                }
            }, acc);
    } catch (java.security.PrivilegedActionException pae) {
        throw (ClassNotFoundException) pae.getException();
    }
    if (result == null) {
        throw new ClassNotFoundException(name);
    }
    return result;
}

protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                     ProtectionDomain protectionDomain)
    throws ClassFormatError
{
    protectionDomain = preDefineClass(name, protectionDomain);
    String source = defineClassSourceLocation(protectionDomain);
    Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
    postDefineClass(c, protectionDomain);
    return c;
}

/* 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;
}

classLoader.getResources("META-INF/spring.factories")

public URL getResource(String name) {
    URL url;
    if (parent != null) {
        url = parent.getResource(name);
    } else {
        url = getBootstrapResource(name);
    }
    if (url == null) {
        url = findResource(name);
    }
    return url;
}

protected URL findResource(String name) {
    return null;
}

public URL findResource(final String name) {
    /*
     * The same restriction to finding classes applies to resources
     */
    URL url = AccessController.doPrivileged(
        new PrivilegedAction<URL>() {
            public URL run() {
                return ucp.findResource(name, true);
            }
        }, acc);

    return url != null ? ucp.checkURL(url) : null;
}