类加载机制

protected Class<?> loadClass(String name, boolean resolve)    throws ClassNotFoundException{    synchronized (getClassLoadingLock(name)) {        // First, check if the class has already been loaded        Class<?> c = findLoadedClass(name);        if (c == null) {            long t0 = System.nanoTime();            try {                if (parent != null) {                    c = parent.loadClass(name, false);                } else {                    c = findBootstrapClassOrNull(name);                }            } catch (ClassNotFoundException e) {                // ClassNotFoundException thrown if class not found                // from the non-null parent class loader            }
            if (c == null) {                // If still not found, then invoke findClass in order                // to find the class.                long t1 = System.nanoTime();                c = findClass(name);
                // this is the defining class loader; record the stats                PerfCounter.getParentDelegationTime().addTime(t1 - t0);                PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);                PerfCounter.getFindClasses().increment();            }        }        if (resolve) {            resolveClass(c);        }        return c;    }}

//// Source code recreated from a .class file by IntelliJ IDEA// (powered by FernFlower decompiler)//
package org.apache.iotdb.udf;
import org.apache.iotdb.udf.api.type.Type;
// $FF: synthetic classclass MySum$1 {    static {        try {            $SwitchMap$org$apache$iotdb$udf$api$type$Type[Type.INT32.ordinal()] = 1;        } catch (NoSuchFieldError var4) {        }
        try {            $SwitchMap$org$apache$iotdb$udf$api$type$Type[Type.INT64.ordinal()] = 2;        } catch (NoSuchFieldError var3) {        }
        try {            $SwitchMap$org$apache$iotdb$udf$api$type$Type[Type.FLOAT.ordinal()] = 3;        } catch (NoSuchFieldError var2) {        }
        try {            $SwitchMap$org$apache$iotdb$udf$api$type$Type[Type.DOUBLE.ordinal()] = 4;        } catch (NoSuchFieldError var1) {        }
    }}

try (UDFClassLoader currentActiveClassLoader =        UDFClassLoaderManager.getInstance().updateAndGetActiveClassLoader()) {      updateAllRegisteredClasses(currentActiveClassLoader);
      Class<?> functionClass = Class.forName(className, true, currentActiveClassLoader);      functionClass.getDeclaredConstructor().newInstance();      udfTable.addUDFInformation(functionName, udfInformation);      udfTable.addFunctionAndClass(functionName, functionClass);    } catch (IOException        | InstantiationException        | InvocationTargetException        | NoSuchMethodException        | IllegalAccessException        | ClassNotFoundException e) {      String errorMessage =          String.format(              "Failed to register UDF %s(%s), because its instance can not be constructed successfully. Exception: %s",              functionName.toUpperCase(), className, e);      LOGGER.warn(errorMessage, e);      throw new UDFManagementException(errorMessage);    }

/** * Closes this URLClassLoader, so that it can no longer be used to load * new classes or resources that are defined by this loader. * Classes and resources defined by any of this loader's parents in the * delegation hierarchy are still accessible. Also, any classes or resources * that are already loaded, are still accessible. * <p> * In the case of jar: and file: URLs, it also closes any files * that were opened by it. If another thread is loading a * class when the {@code close} method is invoked, then the result of * that load is undefined. * <p> * The method makes a best effort attempt to close all opened files, * by catching {@link IOException}s internally. Unchecked exceptions * and errors are not caught. Calling close on an already closed * loader has no effect. * * @exception IOException if closing any file opened by this class loader * resulted in an IOException. Any such exceptions are caught internally. * If only one is caught, then it is re-thrown. If more than one exception * is caught, then the second and following exceptions are added * as suppressed exceptions of the first one caught, which is then re-thrown. * * @exception SecurityException if a security manager is set, and it denies *   {@link RuntimePermission}{@code ("closeClassLoader")} * * @since 1.7 */ public void close() throws IOException {     SecurityManager security = System.getSecurityManager();     if (security != null) {         security.checkPermission(new RuntimePermission("closeClassLoader"));     }     List<IOException> errors = ucp.closeLoaders();
     // now close any remaining streams.
     synchronized (closeables) {         Set<Closeable> keys = closeables.keySet();         for (Closeable c : keys) {             try {                 c.close();             } catch (IOException ioex) {                 errors.add(ioex);             }         }         closeables.clear();     }
     if (errors.isEmpty()) {         return;     }
     IOException firstex = errors.remove(0);
     // Suppress any remaining exceptions
     for (IOException error: errors) {         firstex.addSuppressed(error);     }     throw firstex; }

  if (!information.isBuiltin()) {      Thread.currentThread()        .setContextClassLoader(            UDFClassLoaderManager.getInstance().getActiveClassLoader());    }