类加载机制

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 class
class 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());
    }