反射执行FlinkSql代码时找不到UDF的class报ClassNotFound

最新推荐文章于 2024-10-14 16:20:41 发布

原创最新推荐文章于 2024-10-14 16:20:41 发布 · 2.2k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#scala #big data #开发语言

本文针对 Flink SQL 使用 UDF 函数时出现的 ClassNotFound 异常问题，详细介绍了如何通过自定义 ClassLoader 来解决，并进一步探讨了解决 Cannot load user class 等相关问题的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

通过组件的方式配置flinkSql的流程，其中有测试环节，就是将生成的源代码通过反射执行一遍。其余组件都正常，就是使用UDF的时候报错ClassNotFound。
在这里插入图片描述

udf的注册代码如下：

TableEnvironment tbEnv;
......
tbEnv.createTemporarySystemFunction("udf名字", 全类名.class);

经过排查，它会在如下scala代码中进行实例化。但它实例化的过程中呢是先拿到一个二进制的文件、然后再从Thread.currentThread().getContextClassLoader上下文classLoader里获取udf，但是这个classLoader里面是没有udf的。所以导致报ClassNotFound
在这里插入图片描述
所以就有了解决办法：

在源码中，我们原来就使用了
ParameterTool parameter = ParameterTool.fromArgs(args);
String classPaths = parameter.get("dependFiles", "");
Configuration configuration = parameter.getConfiguration();
ConfigUtils.encodeCollectionToConfig(configuration, PipelineOptions.CLASSPATHS, jarURLs, URL::toString);
将所有的jar的URL传进去。所以在Scala代码里我们可以获取到jar的URL配置：
val urlList : util.List[String] = this.tableConfig.getConfiguration.get(PipelineOptions.CLASSPATHS)
val key : String = this.tableConfig.getConfiguration.get(FlinkScalaUtil.CLASSLOADER_KEY)
然后我们重写CodeGeneratorContext.scala，使它调用自己写的Java代码：FlinkScalaUtil.getURLClassLoaderFormUrlList，返回一个URLClassLoader从而解决问题：
代码如下：

@Slf4j
public class FlinkScalaUtil {

    private static Map<String, ClassLoader> CLASSLOADER_MAP = new ConcurrentHashMap<>();

    public static final ConfigOption<String> CLASSLOADER_KEY = ConfigOptions.key("CLASSLOADER").stringType()
        .defaultValue("CLASSLOADER");


    public static ClassLoader getURLClassLoaderFormUrlList(List<String> depentFiles, ClassLoader parentLoader, String key) throws MalformedURLException {
        if (CLASSLOADER_MAP.containsKey(key)) {
            return CLASSLOADER_MAP.get(key);
        }
        if (depentFiles == null) {
            return parentLoader;
        }
        URL[] urls = new URL[depentFiles.size()];
        for (int i = 0; i < urls.length; i++) {
            urls[i] = new URL(depentFiles.get(i));
        }
        ClassLoader classLoader = new URLClassLoader(urls, parentLoader);
        CLASSLOADER_MAP.put(key, classLoader);
        return classLoader;
    }


    public static ClassLoader getURLClassLoaderFromConfig(TableConfig config, ClassLoader parentLoader) {
        String key = config.getConfiguration().get(CLASSLOADER_KEY);
        if (CLASSLOADER_MAP.containsKey(key)) {
            return CLASSLOADER_MAP.get(key);
        }

        List<String> list = config.getConfiguration().get(PipelineOptions.CLASSPATHS);

        if (list == null) {
            return  parentLoader;
        }

        URL[] urls = new URL[list.size()];
        int i = 0;
        try {
            for (String filePath : list) {
                URL url = new URL(filePath);
                urls[i] = url;
                i++;
            }
        } catch (IOException e) {
            log.warn("依赖jar【{}】失败：{}",String.join(Constant.COMMA, list),  e.getMessage());
        }
        ClassLoader classLoader = new URLClassLoader(urls, parentLoader);
        CLASSLOADER_MAP.put(key, classLoader);
        return classLoader;
    }

    public static void removeClassLoader(String key) {
        CLASSLOADER_MAP.remove(key);
    }
}

与此类似的类还有 UserDefinedFunctionHelper类

--------------------------------------------------------

上述问题解决之后。又出现新的问题Cannot load user class: xxx
ClassLoader info: URL ClassLoader:
Class not resolvable through given classloader
在这里插入图片描述
我们查看代码InstantiationUtil deserializeObject()发现classLoader是传进来的，但是却找不到，所以看看classLoader是哪里定义的，先找到它：

最后发现是在org.apache.flink.runtime.taskmanager.Task类中找到了创建的方法createUserCodeClassloader方法。它是通过

final UserCodeClassLoader userCodeClassLoader =
            classLoaderHandle.getOrResolveClassLoader(requiredJarFiles, requiredClasspaths);

来加载jar包的，所以找到它是在哪里定义的这两个变量，不过排查下来难度很大，因为在TableEnvironmentImpl.java的executeInternal方法返回就跳到了Task类中，无法知道这两个参数是怎么来的。不过呢我们发现，在执行完函数后回去获取ExecutionConfig对象实例。那我们是否可以在ExecutionConfig对象中存放urlList，然后将其取出来放进getOrResolveClassLoader方法参数里呢呢？
方法如下：

1. 重写TableEnvironmentImpl的executeInternal方法下生成执行计划的函数
Pipeline pipeline = execEnv.createPipeline(transformations, tableConfig, jobName);

2. 重写org.apache.flink.table.planner.delegation.BatchExecutor 的 createPipeline方法，并将url写进来
添加两行代码
execEnv.getConfig().setJarPaths(tableConfig.getConfiguration().get(PipelineOptions.CLASSPATHS));
StreamGraph streamGraph = ExecutorUtils.generateStreamGraph(execEnv, transformations);

3. 反过来重写Task下的createUserCodeClassloader方法，获取ExecutionConfig里的jarUrlList添加进requiredClasspaths参数里。
ExecutionConfig tempConfig = serializedExecutionConfig.deserializeValue(Thread.currentThread()
            .getContextClassLoader());
        List<String> jarPaths = tempConfig.getJarPaths();
        if (jarPaths != null && jarPaths.size() > 0) {
            List<URL> urlList = new ArrayList<>();
            for (String path : jarPaths) {
                urlList.add(new URL(path));
            }
            requiredClasspaths.addAll(urlList);
        }

userCodeClassLoader = createUserCodeClassloader();
final ExecutionConfig executionConfig =
       serializedExecutionConfig.deserializeValue(userCodeClassLoader.asClassLoader());

以此解决了问题，类似的一些问题也得以解决，如CompileException
在这里插入图片描述

--------------------------------------------------------

上述问题解决后，以为已经没问题了，没想到将项目打为jar到服务器上运行的时候，又出现了找不到的问题。问题很好推测：我们自己重写的类没有生效

SpringBoot启动会去加载lib目录下的第三方的jar，再去加载自己写的class类（BOOT-INF下的calss文件），所以就会覆盖了自己重写的方法。
解决办法为：将重写的代码单独打为一个jar包，并且以 ! 或者其它字典顺序高的字符开头，放在lib目录下即可。
我们的打包插件如下，可以进行参考：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <executions>
        <!-- 重写的class文件单独打成jar包放到lib 目录下，名称以!开头保证最先被加载 -->
        <execution>
            <id>PaRewriteClass</id>
            <goals>
                <goal>jar</goal>
            </goals>
            <phase>package</phase>
            <configuration>
                <finalName>!!rewriteClass-${project.version}-${build.time}</finalName>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <classifier>prc</classifier>
                <includes>
               		 <!-- 指定需要打包的类有哪些，这里是org目录下的所有类 -->
                    <include>**/org/**</include>
                </includes>
            </configuration>
        </execution>
    </executions>
    <configuration>
        <archive>
            <manifest>
                <!-- 指定 Spring Boot 启动类，实际测试中必须 -->
                <mainClass>cn.com.xxx.xxx.xxx</mainClass>
                <!-- 将所有第三方 jar 添加到项目 jar 的 MANIFEST.MF 文件中，这样运行 jar 时依赖包才能被加载 -->
                <!-- <addClasspath>true</addClasspath> -->
                <!-- 指定复制第三方 jar 的目标目录为 target/lib/ -->
                <classpathPrefix>./lib/</classpathPrefix>
            </manifest>
        </archive>
    </configuration>
</plugin>

至此完成，我们可以学习到flink的classLoader的处理逻辑、SpringBoot类的加载顺序