Java 9 打破模块的封装

主要介绍以下内容：

什么是打破模块的封装
如何使用命令行选项将依赖项（添加需要）添加到模块
如何使用--add-exports命令行选项导出模块的未导出包，并使用可执行JAR的MANIFEST.MF文件
如何使用--add-opens命令行选项并使用可执行JAR的MANIFEST.MF文件打开模块的非开放包
如何使用--add-reads命令行选项增加模块的可读性

一. 什么是打破模块的封装

JDK 9的主要目标之一是将类型和资源封装在模块中，并仅导出其他模块要访问其公共类型的软件包。有时，可能需要打破模块指定的封装，以启用白盒测试或使用不受支持的JDK内部API或类库。这可以通过在编译时和运行时使用非标准命令行选项来实现。具有这些选项的另一个原因是向后兼容性。并不是所有现有的应用程序将完全迁移到JDK 9并将被模块化。如果这些应用程序需要使用以前是公开的但已经封装在JDK 9中的库提供的JDK API或API，则这些应用程序有一种方法可以继续工作。其中一些选项具有可以添加到可执行JAR的MANIFEST.MF文件中的对应属性，以避免使用命令行选项。

Tips
使用Module API也可以使用每个命令行选项来打破模块的封装。

虽然可能听起来像这些选项与JDK 9之前的操作相同，但是在访问JDK内部API时没有任何限制。如果模块中的软件包未导出或打开，则表示模块的设计人员无意在模块外部使用这些软件包。这样的包可能会被修改或甚至从模块中删除，无需任何通知。如果仍然使用这些软件包通过使用命令行选项导出或打开它们，可能会面临破坏应用程序的风险！

二. 命令行选项

模块声明中的三个模块语句（statement）允许模块封装其类型和资源，并让其他模块使用来自第一个模块的封装类型和资源。这些语句是exports, opens, 和requires。每个模块语句都有一个命令行选项。对于exports和opens语句，可以在JAR的manifest文件中使用相应的属性。下表列出了这些语句及其相应的命令行选项和清单属性。在以下部分详细描述这些选项。

Module Statement	Command-Line Option	Manifest Attribute
exports	–add-exports	Add-Exports
opens	–add-opens	Add-Opens
requires	–add-reads	无属性可用

Tips
您可以在相同的命令行中多次使用--add-exports，--add-opens和--add-reads命令行选项。

1. `--add-exports`选项

模块声明中的exports语句将模块中的包导出到所有或其他模块，因此这些模块可以使用该包中的公共API。如果程序包未由模块导出，则可以使用-add-exports的命令行选项导出程序包。其语法如下：

1	--add-exports <source-module>/<package>=<target-module-list>

这里，<source-module>是将<package>导出到<target-module-list>的模块，它是以逗号分隔的目标模块名称列表。相当于向<source-module>的声明添加一个限定的exports语句：

module <source-module> {
    exports <package> to <target-module-list>;
    // More statements go here
}

Tips
如果目标模块列表是特殊值ALL-UNNAMED，对于--add-exports选项，模块的包将导出到所有未命名的模块。 --add-exports选项可用于javac和java命令。

以下选项将java.base模块中的sun.util.logging包导出到com.jdojo.test和com.jdojo.prime模块：

1	--add-exports java.base/sun.util.logging=com.jdojo.test,com.jdojo.prime

以下选项将java.base模块中的sun.util.logging包导出到所有未命名的模块：

1	--add-exports java.base/sun.util.logging=ALL-UNNAMED

2. `--add-opens`选项

模块声明中的opens语句使模块里面的包对其他模块开放，因此这些模块可以在运行期使用深层反射访问该程序包中的所有成员类型。如果一个模块的包未打开，可以使用--add-opens命令行选项打开它。其语法如下：

1	--add-opens <source-module>/<package>=<target-module-list>

这里，<source-module>是打开<package>到<target-module-list>的模块，它是以逗号分隔的目标模块名称列表。相当于向<source-module>的声明添加一个限定的opens语句：

module <source-module> {
    opens <package> to <target-module-list>;
    // More statements go here
}

Tips
如果目标模块列表是特殊值ALL-UNNAMED，对于--add-opened选项，模块的软件包对所有未命名的模块开放。 --add-opened选项可用于java命令。在编译时使用javac命令使用此选项会生成警告，但没有影响。

以下选项将java.base模块中的sun.util.logging包对com.jdojo.test和com.jdojo.prime模块开放：

1	--add-opens java.base/sun.util.logging=com.jdojo.test,com.jdojo.prime

以下选项将java.base模块中的sun.util.logging包对所有未命名的模块开放：

1	--add-opens java.base/sun.util.logging=ALL-UNNAMED

3.`--add-reads` 选项

--add-reads选项不是关于打破封装。相反，它是关于增加模块的可读性。在测试和调试过程中，即使第一个模块不依赖于第二个模块，模块有时也需要读取另一个模块。模块声明中的requires语句用于声明当前模块对另一个模块的依赖关系。可以使用--add-reads命令行选项将可读性边缘从模块添加到另一个模块。这对于将第一个模块添加requires语句具有相同的效果。其语法如下：

1	--add-reads <source-module>=<target-module-list>

<source-module>是其定义被更新以读取<target-module-list>中指定的模块列表的模块，该目标模块名称是以逗号分隔的列表。相当于将目标模块列表中每个模块的源模块添加一个requires语句：

module <source-module> {
    requires <target-module1>;
    requires <target-module2>;
    // More statements go here
}

Tips
如果目标模块列表是特殊值ALL-UNNAMED，则对于--add-reads选项，源模块读有未命名的模块。这是命名模块可以读取未命名模块的唯一方法。没有可以在命名模块声明中使用的等效模块语句来读取未命名的模块。此选项在编译时和运行时可用。

以下选项为com.jdojo.common模块添加了一个读取边界，使其读取jdk.accessibility模块：

1	--add-reads com.jdojo.common=jdk.accessibility

4. `--permit-illegal-access`选项

前面提到的三个命令行选项，用于添加exports ，opens和reads仅用于向后兼容。但是，当需要“非法”访问（反射访问模块中类型不可访问的成员）到几个模块时，使用这些选项是乏味的。对于这种情况，java命令可以使用--permit-illegal-access选项。顾名思义，它允许通过使用深层反射的任何未命名模块（类路径中的代码）的代码非法访问任何命名模块中的类型的成员。其语法如下：

1	java --permit-illegal-access <other-options-and-arguments>

--permit-illegal-access选项不允许将命名模块中的代码非法访问其他命名模块中的类型的成员。在这种情况下，可以将此选项与--add-exports，--add-opens和--add-reads选项组合使用。

Tips
--permit-illegal-access选项在JDK 9中可用，并将在JDK 10中删除。使用此选项会在标准错误流上打印警告。一个警告打印一个消息，规定此选项将在将来的版本中被删除。其他警告报告了授予非法访问的代码的详细信息，授予非法访问的代码以及授予访问权限的选项。

在下一节中介绍一个使用所有这些选项的示例，这些选项允许打破模块封装。

三. 一个示例

我们来看一下打破封装的例子。我使用一个简单的例子。它的目的是展示可用于打破封装的所有概念和命令行选项。

使用之前创建com.jdojo.intro模块作为第一个模块。它在com.jdojo.intro包中包含一个Welcome类。该模块不导出包，所以Welcome类被封装，不能在模块外部访问。在这个例子中，从另一个模块com.jdojo.intruder调用Welcome类的main()方法。其声明如下所示。

// module-info.java
module com.jdojo.intruder {
    // No module statements
}

下面显示了此模块中TestNonExported类的代码。

// TestNonExported.java
package com.jdojo.intruder;
import com.jdojo.intro.Welcome;
public class TestNonExported {
    public static void main(String[] args) {
        Welcome.main(new String[]{});
    }
}

TestNonExported类只包含一行代码。它调用Welcome类的静态方法main()传递一个空的String数组。如果该类被编译并运行，则在运行Welcome类时打印与第3章中相同的消息：

1 2	Welcome to the Module System. Module Name: com.jdojo.intro

编译com.jdojo.intruder模块的代码：

1
2
3

C:\Java9Revealed>javac --module-path com.jdojo.intro\dist
-d com.jdojo.intruder\build\classes
com.jdojo.intruder\src\module-info.java com.jdojo.intruder\src\com\jdojo\intruder\TestNonExported.java

如果收到如下错误：

com.jdojo.intruder\src\com\jdojo\intruder\TestNonExported.java:4: error: package com.jdojo.intro is not visible
import com.jdojo.intro.Welcome;
                ^
  (package com.jdojo.intro is declared in module com.jdojo.intro, but module com.jdojo.intruder does not read it)
1 error

该命令使用--module-path选项将com.jdojo.intro模块包含在模块路径上。编译时错误指向导入com.jdojo.intro.Welcome类的import语句。它声明包com.jdojo.intro对于com.jdojo.intruder模块是不可见的。也就是说，com.jdojo.intro模块不导出包含Welcome类的com.jdojo.intro包。要解决此错误，需要使用--add-exports命令行选项将com.jdojo.intro模块的com.jdojo.intro包导出到com.jdojo.intruder模块中：

C:\Java9Revealed>javac --module-path com.jdojo.intro\dist
--add-exports com.jdojo.intro/com.jdojo.intro=com.jdojo.intruder
-d com.jdojo.intruder\build\classes
com.jdojo.intruder\src\module-info.java com.jdojo.intruder\src\com\jdojo\intruder\TestNonExported.java

但是仍然报错：

warning: [options] module name in --add-exports option not found: com.jdojo.intro
com.jdojo.intruder\src\com\jdojo\intruder\TestNonExported.java:4: error: package com.jdojo.intro is not visible
import com.jdojo.intro.Welcome;
                ^
  (package com.jdojo.intro is declared in module com.jdojo.intro, but module com.jdojo.intruder does not read it)
1 error
1 warning

这一次，你会得到警告和错误。错误与以前相同。该警告消息指出编译器找不到com.jdojo.intro模块。因为这个模块没有依赖关系，所以即使在模块路径中也没有解决这个模块。要解决警告，需要使用–add-modules选项将com.jdojo.intro模块添加到默认的根模块中：

C:\Java9Revealed>javac --module-path com.jdojo.intro\dist
--add-modules com.jdojo.intro
--add-exports com.jdojo.intro/com.jdojo.intro=com.jdojo.intruder
-d com.jdojo.intruder\build\classes
com.jdojo.intruder\src\module-info.java
com.jdojo.intruder\src\com\jdojo\intruder\TestNonExported.java

即使com.jdojo.intruder模块未读取com.jdojo.intro模块，此javac命令仍然成功。这似乎是一个错误。如果它不是一个bug，那么没有找到支持这种行为的文档。稍后，将看到java命令将不适用于相同的模块。如果此命令出错，并显示一条消息，表示TestNonExported类无法访问Welcome类，请添加以下选项来修复它：

1	--add-reads com.jdojo.intruder=com.jdojo.intro

尝试使用以下命令重新运行TestNonExported类，该命令包括模块路径上的com.jdojo.intruder模块：

C:\Java9Revealed>java --module-path com.jdojo.intro\dist;com.jdojo.intruder\build\classes
--add-modules com.jdojo.intro
--add-exports com.jdojo.intro/com.jdojo.intro=com.jdojo.intruder
--module com.jdojo.intruder/com.jdojo.intruder.TestNonExported

但是会报出以下错误信息：

1
2

Exception in thread "main" java.lang.IllegalAccessError: class com.jdojo.intruder.TestNonExported (in module com.jdojo.intruder) cannot access class com.jdojo.intro.Welcome (in module com.jdojo.intro) because module com.jdojo.intruder does not read module com.jdojo.intro
        at com.jdojo.intruder/com.jdojo.intruder.TestNonExported.main(TestNonExported.java:8)

错误信息已经很清晰。它声明com.jdojo.intruder模块必须读取com.jdojo.intro模块，以便前者使用后者的Welcome类。可以使用--add-reads选项来修复错误，该选项将在com.jdojo.intruder模块中添加一个读取边界（等同于requires语句）以读取com.jdojo.intro模块。以下命令执行此操作：

C:\Java9Revealed>java --module-path com.jdojo.intro\dist;com.jdojo.intruder\build\classes
--add-modules com.jdojo.intro
--add-exports com.jdojo.intro/com.jdojo.intro=com.jdojo.intruder
--add-reads com.jdojo.intruder=com.jdojo.intro
--module com.jdojo.intruder/com.jdojo.intruder.TestNonExported

输出结果为：

1 2	Welcome to the Module System. Module Name: com.jdojo.intro

这一次，你会收到所期望的输出。下图显示了运行此命令时创建的模块图。

com.jdojo.intruder和com.jdojo.intro模块都是根模块。 com.jdojo.intruder模块被添加到默认的根模块中，因为正在运行的主类在此模块中。 com.jdojo.intro模块通过--add-modules选项添加到默认的根模块集中。通过--add-reads选项从com.jdojo.intruder模块将一个读取边界添加到com.jdojo.intro模块。模块图中，使用虚线显示了从前者到后者的读取，以便在构建模块图之后作为--add-reads选项的结果添加它。使用此命令使用-Xdiag:resolver选项来查看模块的解决方法。

来看看另一个例子，它将展示如何使用--add-opens命令行选项打开一个包到另一个模块。在第4章中，有一个com.jdojo.address模块，其中包含com.jdojo.address包中的Address类。该模块导出com.jdojo.address包。该类包含一个名为line1的私有字段，有一个public getLine1()方法返回line1字段的值。

如下代码所示，TestNonOpen类尝试加载Address类，创建类的实例，并访问其公共和私有成员。 TestNonOpen类是com.jdojo.intruder模块的成员。在main()方法的throws子句中添加了一些异常，以保持逻辑简单。在实际的程序中，在try-catch块中处理它们。

// TestNonOpen.java
package com.jdojo.intruder;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestNonOpen {
    public static void main(String[] args)
            throws IllegalAccessException, IllegalArgumentException,
            NoSuchMethodException, ClassNotFoundException,
            InvocationTargetException, InstantiationException,
            NoSuchFieldException {
        String className = "com.jdojo.address.Address";
        // Get the class reference
        Class<?> cls = Class.forName(className);
        // Get the no-args constructor
        Constructor constructor = cls.getConstructor();
        // Create an Object of the Address class
        Object address = constructor.newInstance();
        // Call the getLine1() method to get the line1 value
        Method getLine1Ref = cls.getMethod("getLine1");
        String line1 = (String)getLine1Ref.invoke(address);
        System.out.println("Using method reference, Line1: " + line1);
        // Use the private line1 instance variable to read its value
        Field line1Field = cls.getDeclaredField("line1");
        line1Field.setAccessible(true);
        String line11 = (String)line1Field.get(address);
        System.out.println("Using private field reference, Line1: " + line11);
    }
}

使用以下命令编译TestNonOpen类：

1 2	C:Java9revealed> javac -d com.jdojo.intruder\build\classes com.jdojo.intruder\src\com\jdojo\intruder\TestNonOpen.java

TestNonOpen类编译正常。请注意，它使用深层反射访问Address类，编译器不知道此类不允许读取Address类及其私有字段。现在尝试运行TestNonOpen类：

1
2
3

C:Java9revealed> java --module-path com.jdojo.address\dist;com.jdojo.intruder\build\classes
--add-modules com.jdojo.address
--module com.jdojo.intruder/com.jdojo.intruder.TestNonOpen

会出现以下错误信息：

Using method reference, Line 1: 1111 Main Blvd.
Exception in thread "main" java.lang.reflect.InaccessibleObjectException: Unable to make field private java.lang.String com.jdojo.address.Address.line1 accessible: module com.jdojo.address does not "opens com.jdojo.address" to module com.jdojo.intruder
        at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:207)
        at java.base/java.lang.reflect.Field.checkCanSetAccessible(Field.java:171)
        at java.base/java.lang.reflect.Field.setAccessible(Field.java:165)
        at com.jdojo.intruder/com.jdojo.intruder.TestNonOpen.main(TestNonOpen.java:35)

使用--add-modules选项将com.jdojo.address模块添加到默认的根模块中。即使com.jdojo.intruder模块没有读取com.jdojo.address模块，也可以实例化Address类。有两个原因：

com.jdojo.address模块导出包含Address类的com.jdojo.address包。因此，其他模块可访问Address类，只要其他模块读取com.jdojo.address模块即可。
Java 反射 API假定所有反射操作都是可读性的。该规则假设com.jdojo.intruder模块读取com.jdojo.address模块，即使在其模块声明中，com.jdojo.intruder模块未读取com.jdojo.address模块。如果要在编译时使用com.jdojo.address包中的类型，例如，声明Address类类型的变量，则com.jdojo.intruder模块必须在它声明或命令行中读取com.jdojo.address模块。

输出显示TestNonOpen类能够调用Address类的public getLine1()方法。但是，当它尝试访问私有line1字段时，抛出异常。回想一下，如果模块导出了类型，其他模块可以使用反射来访问该类型的公共成员。对于其他模块访问类型的私有成员，包含该类型的包必须是打开的。 com.jdojo.address包未打开。因此，com.jdojo.intruder模块无法访问Address类的私有line1字段。为此，可以使用--add-opens选项将com.jdojo.address包打开到com.jdojo.intruder模块中：

C:Java9revealed> java --module-path com.jdojo.address\dist;com.jdojo.intruder\build\classes
--add-modules com.jdojo.address
--add-opens com.jdojo.address/com.jdojo.address=com.jdojo.intruder
--module com.jdojo.intruder/com.jdojo.intruder.TestNonOpen

输出结果为：

1 2	Using method reference, Line1: 1111 Main Blvd. Using private field reference, Line1: 1111 Main Blvd.

现在是时候使用--permit-illegal-access选项了。我们试试从类路径运行TestNonOpen类，如下所示：

1
2
3

C:\Java9Revealed>java --module-path com.jdojo.address\dist
--class-path com.jdojo.intruder\build\classes
--add-modules com.jdojo.address com.jdojo.intruder.TestNonOpen

输出结果为：

Using method reference, Line1: 1111 Main Blvd.
Exception in thread "main" java.lang.reflect.InaccessibleObjectException: Unable to make field private java.lang.String com.jdojo.address.Address.line1 accessible: module com.jdojo.address does not "opens com.jdojo.address" to unnamed module @9f70c54
        at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:337)
        at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:281)
        at java.base/java.lang.reflect.Field.checkCanSetAccessible(Field.java:175)
        at java.base/java.lang.reflect.Field.setAccessible(Field.java:169)
        at com.jdojo.intruder.TestNonOpen.main(TestNonOpen.java:34)

从输出可以看出，由于它位于类路径上，加载到未命名模块中的TestNonOpen类能够在com.jdojo.address模块中读取导出的类型及其公共方法。但是，它无法访问私有实例变量。可以使用--permit-illegal-access选项修复此问题，如下所示：

C:\Java9Revealed>java --module-path com.jdojo.address\dist
--class-path com.jdojo.intruder\build\classes
--add-modules com.jdojo.address
--permit-illegal-access com.jdojo.intruder.TestNonOpen

输出结果为：

WARNING: --permit-illegal-access will be removed in the next major release
Using method reference, Line1: 1111 Main Blvd.
WARNING: Illegal access by com.jdojo.intruder.TestNonOpen (file:/C:/Java9Revealed/com.jdojo.intruder/build/classes/) to field com.jdojo.address.Address.line1 (permitted by --permit-illegal-access)
Using private field reference, Line1: 1111 Main Blvd.

请注意，由于--permit-illegal-access选项的警告和TestNonOpen类的消息的都会混合在输出中。

四. 使用JAR的Manifest属性

可执行的JAR是一个JAR文件，可用于使用如下所示的-jar选项直接运行Java应用程序：

1	java -jar myapp.jar

这里，myapp.jar被称为可执行JAR。其MANIFEST.MF文件中的可执行JAR包含一个名为Main-Class的属性，其值是java命应运行的主类的完全限定名。回想一下，还有其他种类的JAR，如模块化JAR和多版本JAR。 JAR基于哪种JAR无关紧要；可执行JAR仅在使用-jar选项用于启动应用程序的方式的上下文中定义。

考虑现有应用程序作为可执行JAR。假设应用程序使用深层反射来访问JDK内部API。它在JDK 8中工作正常。希望在JDK 9上运行可执行文件JAR。JDK 9中的JDK内部API已封装。现在，必须使用--add-exports和-add-opens命令行选项协同-jar选项来运行相同的可执行文件JAR。在JDK 9中使用新的命令行选项提供了一个解决方案。然而，对于可执行JAR的最终用户来说，这是不方便的。要使用JDK 9，他们需要知道所需要使用的新的命令行选项。为了缓解这种迁移，JDK 9中添加了可执行JAR的MANIFEST.MF文件的两个新属性：

1 2	Add-Exports Add-Opens

这些属性将添加到manifest文件的主要部分。它们是--add-exports和--add-opened两个命令行选项的对应。使用这些属性有一个区别。它们导出和打开模块的包给所有的未命名模块。因此，可以指定源模块列表，它们的包不必将目标模块指定为这些属性的值。换句话说，在manifest文件中，可以导出或打开包给所有的未命名模块，也可以不打开所选模块。这些属性的值是以分隔开的模块名/包名称对的空格分隔的列表。这是一个例子：

1	Add-Exports: m1/p1 m2/p2 m3/p3 m1/p1

该条目将将模块m1中的软件包p1，模块m2中的软件包p2，模块m3中的软件包p3导出到所有未命名的模块。解析manifest文件的规则是宽松的，并允许重复。请注意该值中的重复条目m1/p1。在运行时，这些包将被导出到所有未命名的模块。

来看一个例子。这个例子很简单，java.lang.Long类包含一个名为serialVersionUID私有静态字段，声明如下：

1	private static final long serialVersionUID = 4290774380558885855L;

下面包含使用深层反射访问Long.serialVersionUID字段的TestManifestAttributes类的代码。该类在com.jdojo.intruder模块中。现有应用程序不使用模块，它们将使用JDK版本8或更低版本开发。但是，对于这个例子，它没有任何区别。

// TestManifestAttributes.java
package com.jdojo.intruder;
import java.lang.reflect.Field;
public class TestManifestAttributes {
    public static void main(String[] args) throws NoSuchFieldException,
                     IllegalArgumentException, IllegalAccessException {
        Class<Long> cls = Long.class;
        Field svUid = cls.getDeclaredField("serialVersionUID");
        svUid.setAccessible(true);
        long svUidValue = (long)svUid.get(null);
        System.out.println("Long.serialVersionUID=" + svUidValue);
    }
}

TestManifestAttributes类编译没有任何错误。我们把它打包成一个可执行的JAR。如下显示了在JDK 9之前可执行的JAR中的MANIFEST.MF文件的内容。MANIFEST.MF文件保持在JAR文件根目录下的META-INF目录中。

1 2	Manifest-Version: 1.0 Main-Class: com.jdojo.intruder.TestManifestAttributes

以下命令将创建名为com.jdojo.intruder.jar的可执行文件JAR：可执行文件JAR将被放置在com.jdojo.intruder\dist目录中。或者，可以从NetBeans IDE中清理并构建com.jdojo.intruder项目，以创建此JAR。

1
2
3

C:\Java9Revealed>jar --create --file com.jdojo.intruder\dist\com.jdojo.intruder.jar
--manifest=com.jdojo.intruder\src\META-INF\MANIFEST.MF
-C com.jdojo.intruder\build\classes.

现在运行可执行文件JAR：

1	C:\Java9Revealed>java -jar com.jdojo.intruder\dist\com.jdojo.intruder.jar

会出现以下错误信息：

Exception in thread "main" java.lang.reflect.InaccessibleObjectException: Unable to make field private static final long java.lang.Long.serialVersionUID accessible: module java.base does not "opens java.lang" to unnamed module @224aed64
        at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:207)
        at java.base/java.lang.reflect.Field.checkCanSetAccessible(Field.java:171)
        at java.base/java.lang.reflect.Field.setAccessible(Field.java:165)
        at com.jdojo.intruder.TestManifestAttributes.main(TestManifestAttributes.java:10)

运行时错误表明应用程序无法访问私有静态serialVersionUID，因为java.base模块中的java.lang包未打开。我们先试试--add-opens这个选项：

1 2	C:\Java9Revealed>java --add-opens java.base/java.lang=ALL-UNNAMED -jar com.jdojo.intruder\dist\com.jdojo.intruder.jar

输出信息如下：

1	Long.serialVersionUID=4290774380558885855

此命令工作正常，并验证命令行选项是这种情况下的解决方案。我们使用MANIFEST.MF文件中的Add-Opens属性来修复此错误，如下所示。

1
2
3

Manifest-Version: 1.0
Main-Class: com.jdojo.intruder.TestManifestAttributes
Add-Opens: java.base/java.lang

使用相同的命令重新创建可执行文件JAR并运行它：

1	C:\Java9Revealed>java -jar com.jdojo.intruder\dist\com.jdojo.intruder.jar

输出结果为：

1	Long.serialVersionUID=4290774380558885855

应用程序运行正常。如果JAR不用作可执行JAR，我们来验证是否忽略Add-Opens属性。怎么验证这个？通过将可执行JAR放置在类路径或模块路径上来运行应用程序，并且期望运行时发生错误。请注意，能够在模块路径上运行此应用程序，因为正在使用JDK 9并在JAR中包含模块描述。对于较旧的应用程序，只有一个选项 —— 从类路径运行它。以下命令从类路径运行应用程序：

1	C:\Java9Revealed>java --class-path com.jdojo.intruder\dist\com.jdojo.intruder.jar com.jdojo.intruder.TestManifestAttributes

会出现以下错误：

Exception in thread "main" java.lang.reflect.InaccessibleObjectException: Unable to make field private static final long java.lang.Long.serialVersionUID accessible: module java.base does not "opens java.lang" to unnamed module @17ed40e0
        at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:207)
        at java.base/java.lang.reflect.Field.checkCanSetAccessible(Field.java:171)
        at java.base/java.lang.reflect.Field.setAccessible(Field.java:165)
        at com.jdojo.intruder.TestManifestAttributes.main(TestManifestAttributes.java:10)

如果要使用类路径运行此应用程序，如何解决此错误？使用--add-open命令行选项来修复它：

1 2	C:\Java9Revealed>java --add-opens java.base/java.lang=ALL-UNNAMED --class-path com.jdojo.intruder\dist\com.jdojo.intruder.jar com.jdojo.intruder.TestManifestAttributes

五. 总结

JDK 9的主要目标之一是将类型和资源封装在模块中，并仅导出其他模块要访问其公共类型的软件包。有时，可能需要打破模块指定的封装，以启用白盒测试或使用不受支持的JDK内部API或库。这可以通过在编译时和运行时使用非标准命令行选项来实现。具有这些选项的另一个原因是向后兼容性。

JDK 9提供了两个命令行选项--add-exports和-add-opened，可以在模块声明中定义封装。 --add-exports选项允许在模块中将未导出的包导出到编译时和运行时的其他模块。--add-opened选项允许在模块中打开一个非开放的软件包到其他模块，以便在运行时进行深度反射。这些选项的值为/=，其中<source-module>是导出或打开<package>到<target-module-list>，它是以逗号分隔的目标模块名称列表。可以使用ALL-UNNAMED作为将所有未命名模块导出或打开的目标模块列表的特殊值。

有两个名为Add-Exports和Add-Opens的新属性可用于可执行JAR的manifest 文件的主要部分。使用这些属性的效果与使用类似命名的命令行选项相同，只是这些属性将指定的包导出或打开到所有未命名的模块。这些属性的值是以空格分隔的斜体分隔的module-name/package-name对列表。例如，可执行JAR的manifest文件的主要部分中的Add-Opens:java.base/java.lang条目将为java.base模块中的所有未命名模块打开java.lang包。

在测试和调试过程中，有时需要一个模块读取另一个模块，其中第一个模块在其声明中不使用requires语句来读取第二个模块。这可以使用--add-reads命令行选项来实现，该选项的值以<source-module>=<target-module-list>的形式指定。<source-module>是其定义被更新以读取在<target-module-list>中指定的模块列表的模块，该模块是目标模块名称的逗号分隔列表。目标模块列表的ALL-UNNAMED的特殊值使得源模块读取所有未命名的模块。

一. 什么是打破模块的封装

二. 命令行选项

1. --add-exports选项

2. --add-opens选项

3.--add-reads 选项

4. --permit-illegal-access选项

三. 一个示例

四. 使用JAR的Manifest属性

五. 总结

1. `--add-exports`选项

2. `--add-opens`选项

3.`--add-reads` 选项

4. `--permit-illegal-access`选项