迁移至Java Modules时遇Confluent Kafka拆分包问题求解决方案

问题背景 #

迁移至Java Modules时触发拆分包错误：

module myproject reads package io.confluent.kafka.serializers from both kafka.schema.serializer and kafka.avro.serializer

冲突源于kafka.avro.serializer和kafka.schema.serializer两个自动模块共享io.confluent.kafka.serializers包，且前者依赖后者无法直接排除传递依赖；重新打包合并JAR受公司安全政策限制，Confluent官方重构时间不可控。

项目层面可行解决方案 #

1. Maven Shade插件重命名冲突包 #

通过重命名其中一个依赖的冲突包路径，规避Java Modules的拆分包检测。在POM中添加如下配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.5.1</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <relocations>
                            <!-- 将kafka.schema.serializer的冲突包重命名 -->
                            <relocation>
                                <pattern>io.confluent.kafka.serializers</pattern>
                                <shadedPattern>io.confluent.kafka.serializers.schema</shadedPattern>
                            </relocation>
                        </relocations>
                        <!-- 仅对kafka.schema.serializer执行重命名操作 -->
                        <artifactSet>
                            <includes>
                                <include>io.confluent:kafka-schema-serializer</include>
                            </includes>
                        </artifactSet>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

• 核心逻辑：修改kafka.schema.serializer中冲突包的路径，让两个模块的包名不再重复，从根源消除拆分包冲突。
• 注意事项：项目中所有引用kafka.schema.serializer相关类的代码，需同步替换为新包路径；可配合maven-dependency-plugin分析依赖树，确认无遗漏引用。

2. 在module-info.java中限定模块读取权限 #

若项目仅需其中一个依赖的冲突包类，可通过模块声明规则缩小冲突范围：

module myproject {
    // 明确依赖kafka.avro.serializer
    requires kafka.avro.serializer;
    // 将kafka.schema.serializer标记为可选依赖，仅允许读取其非冲突包
    requires static kafka.schema.serializer;
    
    exports your.project.package;
    // 仅向kafka.avro.serializer开放项目包
    opens your.project.package to kafka.avro.serializer;
}

• 核心逻辑：利用requires static声明可选依赖，引导Java Modules优先使用kafka.avro.serializer的冲突包，忽略kafka.schema.serializer中的重复包。
• 局限：仅适用于项目不同时依赖两个模块冲突包类的场景。

3. Maven Dependency Plugin手动排除冲突类 #

无法排除整个传递依赖时，可手动解压依赖并排除冲突包：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>3.6.0</version>
            <executions>
                <execution>
                    <id>unpack-dependencies</id>
                    <phase>prepare-package</phase>
                    <goals>
                        <goal>unpack</goal>
                    </goals>
                    <configuration>
                        <artifactItems>
                            <!-- 解压kafka.avro.serializer，保留全部类 -->
                            <artifactItem>
                                <groupId>io.confluent</groupId>
                                <artifactId>kafka-avro-serializer</artifactId>
                                <version>${confluent.version}</version>
                                <outputDirectory>${project.build.directory}/classes</outputDirectory>
                            </artifactItem>
                            <!-- 解压kafka.schema.serializer，排除冲突包 -->
                            <artifactItem>
                                <groupId>io.confluent</groupId>
                                <artifactId>kafka-schema-serializer</artifactId>
                                <version>${confluent.version}</version>
                                <outputDirectory>${project.build.directory}/classes</outputDirectory>
                                <excludes>io/confluent/kafka/serializers/**</excludes>
                            </artifactItem>
                        </artifactItems>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

• 核心逻辑：手动合并两个依赖的类到项目编译目录，移除其中一个依赖的冲突包，确保最终编译产物中只有一份io.confluent.kafka.serializers包。
• 注意事项：需确认两个依赖的冲突包类无重叠使用场景，否则会触发ClassNotFound错误；需保持两个依赖版本一致，避免其他兼容性问题。

内容的提问来源于stack exchange，提问作者mdrg