自定义 ClassLoader 读取 JAR 字节并直接调用 defineClass 时,JAR Manifest 中的 sealed package 约束可能不会生效。封闭包一旦在运行时被定义成普通包,外部 JAR 中的同包名类就可能进入同一个运行时包,并访问包级私有成员。

01|封闭包的边界假设

JAR Manifest 支持通过 Sealed: true 将包绑定到单一代码来源。包被封闭后,同一包名下的类只能继续从相同来源加载。这里的 sealed package 属于 JAR 与类加载阶段的约束,不是 Java 语言层面的 sealed class。

插件加载器、热更新加载器、脚本桥接加载器、内存字节码加载器经常会自行读取 .class 字节,再调用 defineClass 完成类定义。如果加载器没有读取 Manifest,也没有在定义类前调用带封闭来源的 definePackage,JAR 中声明的封闭包会在运行时退化为普通包。

退化后的直接后果是:外部构造的同包名类型可被同一个自定义加载器定义到目标包内,从而访问包级私有类、方法或字段。

02|底层原理:运行时包的双重身份

Java 包级访问控制不只比较包名,还比较定义类加载器。运行时包由两个条件共同决定:

运行时包 = package name + defining ClassLoader

两个类满足以下条件时,包级私有访问可以通过:

1. package name 完全相同
2. defining ClassLoader 是同一个对象

JAR sealed package 的约束依赖 Package 元数据。标准加载器处理封闭包时,会先读取 Manifest,再根据 Sealed 属性定义或校验包,最后才调用 defineClass:

读取 JAR Manifest
解析 Sealed 属性
调用 definePackage(packageName, ..., sealBase)
调用 defineClass(className, bytes, ...)

Manifest 主属性可写成:

Manifest-Version: 1.0
Sealed: true

包条目属性也可单独声明:

Manifest-Version: 1.0

Name: com/acme/sealed/
Sealed: true

主属性中的 Sealed: true 表示 JAR 内所有包默认封闭。包条目属性优先级更高,可覆盖主属性。

URLClassLoader 会维护该语义。自定义加载器若只执行 defineClass,类定义动作本身不会自动读取 Manifest,也不会自动补充 sealed package 校验。

03|实验构造:三种来源与三条加载路径

构造三个 JAR 来源:

  • app-sealed.jar:包含封闭包 com.acme.sealed,内部有包级私有类 PackageSecret。
  • injected.jar:包含同包名类 Injected,尝试访问 PackageSecret.read()。
  • merged-sealed.jar:将核心类与注入类放入同一个封闭 JAR,用来验证 sealed package 限制的是来源一致性,而不是禁止同包类共存。

加载侧包含三条路径:

  • URLClassLoader:JDK 标准加载器,保留 Manifest sealed package 语义。
  • LooseJarLoader:存在缺陷的自定义加载器,只创建未封闭包并调用 defineClass。
  • FixedJarLoader:修复后的自定义加载器,在 defineClass 前执行 sealed package 校验。

03.1|JDK 工具状态

java -version
javac -version
jar --version

03.2|源码与产物布局

src-app/      核心包源码
src-inject/   外部同包名类源码
src-runner/   加载器与运行入口
manifest/     JAR Manifest
build/        编译产物与 JAR

03.3|核心包:包级私有目标

文件:src-app/com/acme/sealed/PackageSecret.java

cat > src-app/com/acme/sealed/PackageSecret.java <<'EOF'
package com.acme.sealed;

final class PackageSecret {
    static String read() {
        return "internal-token-from-package-private-method";
    }
}
EOF

文件:src-app/com/acme/sealed/Gate.java

cat > src-app/com/acme/sealed/Gate.java <<'EOF'
package com.acme.sealed;

public final class Gate {
    public static String publicCall() {
        return "Gate=" + PackageSecret.read();
    }
}
EOF

文件 src-app/com/acme/sealed/PackageSecret.java 中,PackageSecret 与 read() 都没有 public 修饰符。包外代码不能通过普通 Java 调用直接访问该方法。

03.4|注入类:同包名直接调用

文件:src-inject/com/acme/sealed/Injected.java

cat > src-inject/com/acme/sealed/Injected.java <<'EOF'
package com.acme.sealed;

public final class Injected {
    public static String steal() {
        return "Injected=" + PackageSecret.read();
    }
}
EOF

该调用不使用反射,不使用 setAccessible(true),也不依赖命令行开放模块访问。运行时能否成功,只取决于类加载后的运行时包判断。

03.5|Manifest:绑定封闭来源

文件:manifest/MANIFEST.MF

cat > manifest/MANIFEST.MF <<'EOF'
Manifest-Version: 1.0
Sealed: true

EOF

Manifest 末尾保留空行,避免主属性段被错误解析。

03.6|JAR 读取工具

文件:src-runner/JarSupport.java

cat > src-runner/JarSupport.java <<'EOF'
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Path;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

final class JarSupport {
    private JarSupport() {
    }

    static Manifest readManifest(Path jar) throws IOException {
        try (JarFile jarFile = new JarFile(jar.toFile())) {
            return jarFile.getManifest();
        }
    }

    static byte[] readClassBytes(Path jar, String entryName) throws IOException {
        try (JarFile jarFile = new JarFile(jar.toFile())) {
            JarEntry entry = jarFile.getJarEntry(entryName);
            if (entry == null) {
                return null;
            }

            try (InputStream in = jarFile.getInputStream(entry)) {
                return readAll(in);
            }
        }
    }

    private static byte[] readAll(InputStream in) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[8192];

        while (true) {
            int n = in.read(buffer);
            if (n < 0) {
                break;
            }
            out.write(buffer, 0, n);
        }

        return out.toByteArray();
    }
}
EOF

03.7|缺陷加载器:封闭语义丢失

文件:src-runner/LooseJarLoader.java

cat > src-runner/LooseJarLoader.java <<'EOF'
import java.io.IOException;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;

final class LooseJarLoader extends ClassLoader {
    private final List<Path> jars;

    LooseJarLoader(Path... jars) {
        super(null);
        this.jars = Arrays.asList(jars);
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            Class<?> loaded = findLoadedClass(name);
            if (loaded == null) {
                if (name.startsWith("com.acme.sealed.")) {
                    try {
                        loaded = findClass(name);
                    } catch (ClassNotFoundException ignored) {
                    }
                }
                if (loaded == null) {
                    loaded = super.loadClass(name, false);
                }
            }
            if (resolve) {
                resolveClass(loaded);
            }
            return loaded;
        }
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String entry = name.replace('.', '/') + ".class";

        for (Path jar : jars) {
            try {
                byte[] bytes = JarSupport.readClassBytes(jar, entry);
                if (bytes != null) {
                    // 缺陷点:Manifest 中的 Sealed 属性没有进入 Package 元数据。
                    defineUnsealedPackageIfAbsent(name);
                    return defineClass(name, bytes, 0, bytes.length);
                }
            } catch (IOException e) {
                throw new ClassNotFoundException(name, e);
            }
        }

        throw new ClassNotFoundException(name);
    }

    private void defineUnsealedPackageIfAbsent(String className) {
        int pos = className.lastIndexOf('.');
        if (pos < 0) {
            return;
        }

        String pkgName = className.substring(0, pos);
        if (getDefinedPackage(pkgName) == null) {
            // 最后一个参数为 null,表示运行时包未封闭。
            definePackage(pkgName, null, null, null, null, null, null, null);
        }
    }
}
EOF

03.8|修复加载器:来源一致性校验

文件:src-runner/FixedJarLoader.java

cat > src-runner/FixedJarLoader.java <<'EOF'
import java.io.IOException;
import java.net.URL;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.jar.Attributes;
import java.util.jar.Manifest;

final class FixedJarLoader extends ClassLoader {
    private final List<Path> jars;

    FixedJarLoader(Path... jars) {
        super(null);
        this.jars = Arrays.asList(jars);
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            Class<?> loaded = findLoadedClass(name);
            if (loaded == null) {
                if (name.startsWith("com.acme.sealed.")) {
                    try {
                        loaded = findClass(name);
                    } catch (ClassNotFoundException ignored) {
                    }
                }
                if (loaded == null) {
                    loaded = super.loadClass(name, false);
                }
            }
            if (resolve) {
                resolveClass(loaded);
            }
            return loaded;
        }
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String entry = name.replace('.', '/') + ".class";

        for (Path jar : jars) {
            try {
                byte[] bytes = JarSupport.readClassBytes(jar, entry);
                if (bytes != null) {
                    Manifest manifest = JarSupport.readManifest(jar);
                    // 修复点:定义类之前先定义或校验 Package。
                    defineOrCheckPackage(name, jar, manifest);
                    return defineClass(name, bytes, 0, bytes.length);
                }
            } catch (IOException e) {
                throw new ClassNotFoundException(name, e);
            }
        }

        throw new ClassNotFoundException(name);
    }

    private void defineOrCheckPackage(String className, Path jar, Manifest manifest) throws IOException {
        int pos = className.lastIndexOf('.');
        if (pos < 0) {
            return;
        }

        String pkgName = className.substring(0, pos);
        URL sealBase = jar.toUri().toURL();
        boolean sealedByManifest = isSealedByManifest(className, manifest);
        Package existing = getDefinedPackage(pkgName);

        if (existing == null) {
            // sealedByManifest 为 true 时,将包绑定到当前 JAR URL。
            definePackage(pkgName, null, null, null, null, null, null,
                    sealedByManifest ? sealBase : null);
            return;
        }

        if (existing.isSealed() && !existing.isSealed(sealBase)) {
            throw new SecurityException("sealing violation: package " + pkgName + " is sealed");
        }

        if (!existing.isSealed() && sealedByManifest) {
            throw new SecurityException("sealing violation: package " + pkgName + " was already loaded as unsealed");
        }
    }

    private static boolean isSealedByManifest(String className, Manifest manifest) {
        if (manifest == null) {
            return false;
        }

        int pos = className.lastIndexOf('.');
        if (pos < 0) {
            return false;
        }

        String packageEntry = className.substring(0, pos + 1).replace('.', '/');
        Attributes packageAttributes = manifest.getAttributes(packageEntry);

        String sealed = null;
        if (packageAttributes != null) {
            // 包条目属性优先级高于主属性。
            sealed = packageAttributes.getValue(Attributes.Name.SEALED);
        }
        if (sealed == null) {
            sealed = manifest.getMainAttributes().getValue(Attributes.Name.SEALED);
        }

        return "true".equalsIgnoreCase(sealed);
    }
}
EOF

03.9|运行入口:对照加载路径

文件:src-runner/Main.java

cat > src-runner/Main.java <<'EOF'
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Path;
import java.nio.file.Paths;

public final class Main {
    public static void main(String[] args) throws Exception {
        Path appJar = Paths.get("build/app-sealed.jar").toAbsolutePath();
        Path injectedJar = Paths.get("build/injected.jar").toAbsolutePath();
        Path mergedJar = Paths.get("build/merged-sealed.jar").toAbsolutePath();

        // 不同 JAR:观察标准加载器、缺陷加载器、修复加载器的差异。
        runUrlClassLoaderDifferentJar(appJar, injectedJar);
        runLooseLoaderDifferentJar(appJar, injectedJar);
        runFixedLoaderDifferentJar(appJar, injectedJar);

        // 同一 JAR:证明 sealed package 允许同一来源内的同包类型。
        runUrlClassLoaderSameJar(mergedJar);
        runFixedLoaderSameJar(mergedJar);
    }

    private static void runUrlClassLoaderDifferentJar(Path appJar, Path injectedJar) throws Exception {
        System.out.println("=== URLClassLoader / different JAR ===");

        URL[] urls = new URL[] {
            appJar.toUri().toURL(),
            injectedJar.toUri().toURL()
        };

        try (URLClassLoader loader = new URLClassLoader(urls, null)) {
            // 先加载 Gate,使 com.acme.sealed 包完成定义。
            Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
            System.out.println(call(gate, "publicCall"));
            System.out.println("package sealed = " + sealedState(gate));

            try {
                Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
                System.out.println(call(injected, "steal"));
            } catch (Throwable t) {
                printFailure("URLClassLoader rejected", t);
            }
        }

        System.out.println();
    }

    private static void runLooseLoaderDifferentJar(Path appJar, Path injectedJar) throws Exception {
        System.out.println("=== LooseJarLoader / different JAR ===");

        ClassLoader loader = new LooseJarLoader(appJar, injectedJar);

        // 先加载 Gate,使 com.acme.sealed 包完成定义。
        Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
        System.out.println(call(gate, "publicCall"));
        System.out.println("package sealed = " + sealedState(gate));

        try {
            Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
            System.out.println(call(injected, "steal"));
        } catch (Throwable t) {
            printFailure("LooseJarLoader failed", t);
        }

        System.out.println();
    }

    private static void runFixedLoaderDifferentJar(Path appJar, Path injectedJar) throws Exception {
        System.out.println("=== FixedJarLoader / different JAR ===");

        ClassLoader loader = new FixedJarLoader(appJar, injectedJar);

        // 先加载 Gate,使 com.acme.sealed 包完成定义。
        Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
        System.out.println(call(gate, "publicCall"));
        System.out.println("package sealed = " + sealedState(gate));

        try {
            Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
            System.out.println(call(injected, "steal"));
        } catch (Throwable t) {
            printFailure("FixedJarLoader rejected", t);
        }

        System.out.println();
    }

    private static void runUrlClassLoaderSameJar(Path mergedJar) throws Exception {
        System.out.println("=== URLClassLoader / same JAR ===");

        URL[] urls = new URL[] { mergedJar.toUri().toURL() };

        try (URLClassLoader loader = new URLClassLoader(urls, null)) {
            Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
            Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);

            System.out.println(call(gate, "publicCall"));
            System.out.println("package sealed = " + sealedState(gate));
            System.out.println(call(injected, "steal"));
        }

        System.out.println();
    }

    private static void runFixedLoaderSameJar(Path mergedJar) throws Exception {
        System.out.println("=== FixedJarLoader / same JAR ===");

        ClassLoader loader = new FixedJarLoader(mergedJar);

        Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
        Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);

        System.out.println(call(gate, "publicCall"));
        System.out.println("package sealed = " + sealedState(gate));
        System.out.println(call(injected, "steal"));

        System.out.println();
    }

    private static Object call(Class<?> type, String methodName) throws Exception {
        // 实验方法均为 public static,无需构造实例。
        return type.getMethod(methodName).invoke(null);
    }

    private static String sealedState(Class<?> type) {
        Package pkg = type.getPackage();
        return pkg == null ? "no Package object" : String.valueOf(pkg.isSealed());
    }

    private static void printFailure(String label, Throwable t) {
        // 反射调用失败时展开 InvocationTargetException,输出异常类型。
        Throwable x = t;
        while (x instanceof InvocationTargetException
                && ((InvocationTargetException) x).getTargetException() != null) {
            x = ((InvocationTargetException) x).getTargetException();
        }
        System.out.println(label + ": " + x.getClass().getName() + ": " + x.getMessage());
    }
}
EOF

03.10|核心包编译

mkdir -p build/app-classes
javac -d build/app-classes src-app/com/acme/sealed/*.java
find build/app-classes -type f | sort

03.11|封闭核心 JAR 打包

jar cfm build/app-sealed.jar manifest/MANIFEST.MF -C build/app-classes .
jar tf build/app-sealed.jar | sort

03.12|外部同包名类编译

mkdir -p build/inject-classes
javac -cp build/app-sealed.jar -d build/inject-classes src-inject/com/acme/sealed/Injected.java
find build/inject-classes -type f | sort

编译期能够通过,是因为 Injected.java 声明了相同包名,并且 classpath 中存在 PackageSecret。这不代表运行期一定能加载成功;运行期还要受 sealed package 来源校验影响。

03.13|外部注入 JAR 打包

jar cf build/injected.jar -C build/inject-classes .
jar tf build/injected.jar | sort

03.14|同源合并 JAR 打包

先复制到独立路径,再打包,避免重复条目影响 JAR 生成。

mkdir -p build/merged-classes
cp -R build/app-classes/. build/merged-classes/
cp -R build/inject-classes/. build/merged-classes/
jar cfm build/merged-sealed.jar manifest/MANIFEST.MF -C build/merged-classes .
jar tf build/merged-sealed.jar | sort

03.15|加载器编译与运行

mkdir -p build/runner-classes
javac -d build/runner-classes src-runner/*.java

运行

java -cp build/runner-classes Main

04|包内类型注入的必要前提

包内类型注入成立需要同时满足以下条件:

  1. 受保护类与注入类使用相同包名,如 com.acme.sealed。
  2. 注入类由同一个自定义 ClassLoader 定义。
  3. 自定义加载器未按 Manifest 调用 definePackage 记录封闭来源。
  4. 目标包中存在包级私有类、方法或字段。
  5. 注入类存在可执行入口,如插件入口、脚本桥接入口、服务加载入口或反射调用入口。

缺少同一加载器条件时,包名相同也不会形成同一运行时包。缺少可执行入口时,同包类型即使被定义,也不会自然产生调用效果。

sealed package 的触发点不是 Java 源码编译阶段,而是类加载阶段。Injected.java 能成功编译,只说明编译期的包级访问检查通过;真正决定运行期行为的是 Package 封闭状态与类来源 URL。

05|标准行为、失效行为与修复行为

关键观测点是 LooseJarLoader / different JAR。app-sealed.jar 的 Manifest 已声明 Sealed: true,但运行时输出为 package sealed = false,说明缺陷加载器没有把 sealed package 语义写入 Package 元数据。随后 Injected 被同一个加载器定义到 com.acme.sealed 运行时包中,因此可以直接访问包级私有方法 PackageSecret.read()。

与之对照,URLClassLoader 和 FixedJarLoader 在不同 JAR 来源下都保持 package sealed = true,并拒绝来自 injected.jar 的同包类。same JAR 两组结果则说明 sealed package 限制的是来源一致性,而不是禁止同一来源内存在多个同包类。

06|从 Manifest 到字节码调用

06.1|Manifest 落盘状态

mkdir -p build/manifest-check
cd build/manifest-check
jar xf ../app-sealed.jar META-INF/MANIFEST.MF
cat META-INF/MANIFEST.MF
cd ../..

若 Sealed: true 缺失,app-sealed.jar 不会触发 sealed package 校验。

06.2|包级私有成员状态

javap -classpath build/app-sealed.jar -p com.acme.sealed.PackageSecret

输出中没有 public class,read() 前也没有 public。这证明 Injected 成功调用 read() 时,依赖的是包级访问规则。

06.3|注入调用指令

javap -classpath build/injected.jar:build/app-sealed.jar -c -p com.acme.sealed.Injected

invokestatic 直接指向 PackageSecret.read()。没有反射调用,也没有访问控制绕过 API。

06.4|外部来源依赖

mv build/injected.jar build/injected.jar.bak
java -cp build/runner-classes Main
mv build/injected.jar.bak build/injected.jar

injected.jar 被移走后,different JAR 场景无法找到 Injected。

LooseJarLoader 仍然是 package sealed = false

三个 different JAR 场景都出现 ClassNotFoundException,两个 same JAR 场景仍可执行:

merged-sealed.jar 内部包含 Injected,因此不依赖 injected.jar

这说明 Injected 的可用性与类来源布局直接相关。merged-sealed.jar 场景仍可执行,是因为它不依赖外部 injected.jar。

07|包级访问为何被放行

Injected.steal() 能直接调用 PackageSecret.read(),不是因为使用了 setAccessible(true),也不是因为关闭了访问检查,而是因为 JVM 在解析与校验访问时判定二者处于同一运行时包。

LooseJarLoader 的关键缺陷位于 src-runner/LooseJarLoader.java 的以下逻辑:

if (getDefinedPackage(pkgName) == null) {
    definePackage(pkgName, null, null, null, null, null, null, null);
}

该调用显式创建了未封闭包。后续 defineClass 将 Gate 与 Injected 都定义到同一个 LooseJarLoader 下的 com.acme.sealed 包中,访问条件随即成立。

形成的状态可表示为:

Manifest 声明:Sealed: true
运行时 Package:isSealed() == false
Gate 定义加载器:LooseJarLoader
Injected 定义加载器:LooseJarLoader
包级访问结果:允许

URLClassLoader 与 FixedJarLoader 在不同 JAR 场景中的状态不同:

Manifest 声明:Sealed: true
运行时 Package:isSealed() == true
Gate 来源:app-sealed.jar
Injected 来源:injected.jar
来源一致性:不一致
加载结果:拒绝

同一 JAR 场景中的状态如下:

Manifest 声明:Sealed: true
运行时 Package:isSealed() == true
Gate 来源:merged-sealed.jar
Injected 来源:merged-sealed.jar
来源一致性:一致
加载结果:允许

sealed package 不是加密机制,也不是权限沙箱。它只阻止不同代码来源继续向同一包追加类型。自定义加载器跳过 Manifest 处理后,JAR 打包方基于包边界建立的封装假设会失效。

08|在 defineClass 前恢复封闭语义

修复位置必须在 defineClass 之前。核心策略如下:

1. 从类来源 JAR 读取 Manifest
2. 解析主属性和包属性中的 Sealed
3. 包尚未定义时,使用 definePackage 记录 sealBase
4. 包已经定义且处于封闭状态时,检查当前来源 URL 是否一致
5. 包已经定义为未封闭状态时,拒绝后续封闭来源混入
6. 校验通过后再调用 defineClass

修复分支位于 src-runner/FixedJarLoader.java:

if (existing == null) {
    definePackage(pkgName, null, null, null, null, null, null,
            sealedByManifest ? sealBase : null);
    return;
}

if (existing.isSealed() && !existing.isSealed(sealBase)) {
    throw new SecurityException("sealing violation: package " + pkgName + " is sealed");
}

if (!existing.isSealed() && sealedByManifest) {
    throw new SecurityException("sealing violation: package " + pkgName + " was already loaded as unsealed");
}

sealBase 必须与类来源一致。sealBase 的取值位于 src-runner/FixedJarLoader.java,实验中使用 JAR 文件 URL:

URL sealBase = jar.toUri().toURL();

当 Gate 来自 app-sealed.jar 时,包被绑定到 app-sealed.jar。当 Injected 来自 injected.jar 时,existing.isSealed(sealBase) 返回 false,加载器抛出 SecurityException。

若加载器不准备支持 sealed package,也不应静默忽略 Manifest。更安全的选择是:发现 JAR Manifest 包含 Sealed: true 时拒绝加载,或禁止多个 JAR 定义同一包名。

包级私有适合表达模块内部协作,不适合作为不可信代码隔离边界。只要不可信字节码能由同一个加载器定义到同名包下,包级私有成员就可能被直接调用。

09|sealed package 依赖加载器执行

JAR sealed package 的实际效果依赖类加载器实现。URLClassLoader 会根据 Manifest 维护封闭包约束,自定义 ClassLoader 若只读取字节并调用 defineClass,封闭语义会丢失。

实验中,LooseJarLoader 将 app-sealed.jar 中声明为封闭的包定义成未封闭包,随后成功加载 injected.jar 中的同包类 Injected,并直接访问 PackageSecret.read()。该现象证明 sealed package 校验缺失会导致包内类型注入。

修复路径明确:在 defineClass 前读取 Manifest,按包定义或校验 Package,对封闭包执行来源一致性检查。若业务加载器允许外部字节码进入同一个定义加载器,还需要将包名占用、JAR 来源和 Manifest 语义纳入加载前检查。