protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
    // 上锁
        synchronized (getClassLoadingLock(name)) {
    // 先查询一次
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        // 由父类去查找
                        c = parent.loadClass(name, false);
                    } else {
                        // 使用bootstrap去查询
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // 使用父类和bootstrap还是没有找到，使用findClass去查找
                    long t1 = System.nanoTime();
                    c = findClass(name); // 此方法中存在一个defineClass()方法，此方法会检查类文件是否合法，如自定义一个java.lang.String会检查有错误

                    //记录类加载的信息
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
            // 解析类，是类的连接阶段工作
                resolveClass(c);
            }
            return c;
        }
    }

    public JarFileLifeCycleManager(String jarFilePath, PluginClassLoader.Routing ... routingArray) {
        File file = new File(jarFilePath);
        if (!file.exists()) {
            throw new IllegalArgumentException("jar file does not exist, path=" + jarFilePath);
        }
        final URL[] urLs = getURLs(jarFilePath);
        if (urLs.length == 0) {
            throw new IllegalArgumentException("does not have any available jar in path:" + jarFilePath);
        }
        // 在new一个类加载器时，传递了具体多个jar包的URL
        this.classLoader = new PluginClassLoader(getURLs(jarFilePath), this.getClass().getClassLoader(), routingArray);
    }

ApplicationModel.instance().setConfig(config);
 // 特殊路由表;
 PluginClassLoader.Routing[] routingArray = PluginClassRouting.wellKnownRouting(configInfo.getMode() == Mode.AGENT, 20L);
 String pluginsPath;
 if (StringUtils.isEmpty(config.getPluginsPath())) {
     pluginsPath = PathUtils.getPluginPath();
 } else {
     pluginsPath = config.getPluginsPath();
 }
 lifecycleManager = new JarFileLifeCycleManager(pluginsPath, routingArray);
 //

//    java.security.AccessController#doPrivileged(java.security.PrivilegedAction<T>)
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
    
//    java.util.ServiceLoader#load(java.lang.Class<S>)
    public static <S> ServiceLoader<S> load(Class<S> service) {
        // 使用应用程序类加载器来加载驱动程序
        // 可以手工设置当前的线程上下文的类加载器  Thread.currentThread().setContextClassLoader();
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }

final Class<?> loadedClass = findLoadedClass(name);

while (isPreloading && --timeout > 0 && ClassloaderBridge.instance().findClassInstances(routing.targetClass).size() == 0) {
    try {
        Thread.sleep(100);
        LogUtil.info("{} required {} class router,waiting for class loading", routing.identity, routing.targetClass);
    } catch (InterruptedException e) {
        // ignore
    }
}

DelegateBizClassLoader delegateBizClassLoader = BusinessClassLoaderHolder.getBusinessClassLoader();

@Override
    protected Class<?> loadClass(final String javaClassName, final boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock0(javaClassName)){
            // 优先查询类加载路由表,如果命中路由规则,则优先从路由表中的ClassLoader完成类加载
            if (ArrayUtils.isNotEmpty(routingArray)) {
                for (final Routing routing : routingArray) {
                    if (!routing.isHit(javaClassName)) {
                        continue;
                    }
                    final ClassLoader routingClassLoader = routing.classLoader;
                    try {
                        return routingClassLoader.loadClass(javaClassName);
                    } catch (Exception cause) {
                        // 如果在当前routingClassLoader中找不到应该优先加载的类(应该不可能，但不排除有就是故意命名成同名类)
                        // 此时应该忽略异常，继续往下加载
                        // ignore...
                    }
                }
            }

            // 先走一次已加载类的缓存，如果没有命中，则继续往下加载
            final Class<?> loadedClass = findLoadedClass(javaClassName);
            if (loadedClass != null) {
                return loadedClass;
            }

            try {
                Class<?> aClass = findClass(javaClassName);
                if (resolve) {
                    resolveClass(aClass);
                }
                return aClass;
            } catch (Exception cause) {
                DelegateBizClassLoader delegateBizClassLoader = BusinessClassLoaderHolder.getBussinessClassLoader();
                try {
                    if(null != delegateBizClassLoader){
                        return delegateBizClassLoader.loadClass(javaClassName,resolve);
                    }
                } catch (Exception e) {
                    //忽略异常，继续往下加载
                }
                return RoutingURLClassLoader.super.loadClass(javaClassName, resolve);
            }
        }
    }