Java 语言中不可用的字节码功能

Question

当前（Java 6）是否有一些事情可以在 Java 字节码中完成而在 Java 语言中无法完成？

我知道两者都是图灵完备的，所以将“可以做”理解为“可以做得更快/更好，或者只是以不同的方式”。

我正在考虑额外的字节码，例如 invokedynamic，它无法使用 Java 生成，除非特定的字节码是针对未来版本的。

Answer 1

在使用 Java 字节代码相当长一段时间并对这个问题做了一些额外的研究之后，以下是我的发现摘要：

在调用超级构造函数或辅助构造函数之前在

构造函数 中执行代码在编程语言 (JPL) 中，构造函数的第一条语句必须是对超级构造函数或同一类的另一个构造函数的调用。对于 Java 字节码 (JBC) 来说，情况并非如此。在字节代码中，在构造函数之前执行任何代码都是绝对合法的，只要：

• 在此代码块之后的某个时间调用另一个兼容的构造函数。
• 此调用不在条件语句内。
• 在此构造函数调用之前，不会读取构造实例的任何字段，也不会调用其任何方法。这意味着下一个项目。

在调用超级构造函数或辅助构造函数之前设置实例字段

如前所述，在调用另一个构造函数之前设置实例的字段值是完全合法的。甚至存在一个遗留的 hack，使其能够在 6 之前的 Java 版本中利用此“功能”：

class Foo {
  public String s;
  public Foo() {
    System.out.println(s);
  }
}

class Bar extends Foo {
  public Bar() {
    this(s = "Hello World!");
  }
  private Bar(String helper) {
    super();
  }
}

这样，可以在调用超级构造函数之前设置一个字段，但这不再可能了。在JBC中，这种行为仍然可以实现。

分支超级构造函数调用

在 Java 中，不可能定义像

class Foo {
  Foo() { }
  Foo(Void v) { }
}

class Bar() {
  if(System.currentTimeMillis() % 2 == 0) {
    super();
  } else {
    super(null);
  }
}

这样的构造函数调用，直到 Java 7u23，HotSpot VM 的验证器确实错过了此检查，这就是它可能的原因。这被多个代码生成工具用作一种黑客攻击，但实现这样的类不再合法。

后者只是此编译器版本中的一个错误。在较新的编译器版本中，这又是可能的。

定义一个没有任何构造函数的类

Java 编译器将始终为任何类实现至少一个构造函数。在 Java 字节码中，这不是必需的。这允许创建即使使用反射也无法构造的类。但是，使用 sun.misc.Unsafe 仍然允许创建此类实例。

定义具有相同签名但返回类型不同的方法

在 JPL 中，方法通过其名称及其原始参数类型来标识为唯一。在 JBC 中，还考虑了原始返回类型。

定义名称不不同而仅类型不同的字段

一个类文件可以包含多个同名的字段，只要它们声明不同的字段类型即可。 JVM 始终将字段引用为名称和类型的元组。

抛出未声明的检查异常而不捕获它们

Java 运行时和 Java 字节码不知道检查异常的概念。只有 Java 编译器会验证检查异常是否始终被捕获或在抛出时被声明。

在 lambda 表达式之外使用动态方法调用

所谓的动态方法调用可用于任何东西，不仅仅是 Java 的 lambda 表达式。例如，使用此功能可以在运行时切换执行逻辑。许多归结为 JBC 的动态编程语言都通过使用此指令提高了性能。在 Java 字节代码中，您还可以在 Java 7 中模拟 lambda 表达式，其中编译器尚未允许使用动态方法调用，而 JVM 已经理解该指令。

使用通常不被视为合法的标识符

曾经想过在方法名称中使用空格和换行符吗？创建您自己的 JBC，祝代码审查好运。标识符的唯一非法字符是 .、;、[ 和 /。此外，未命名为 或 的方法不能包含 < 和 >。

重新分配 final 参数或 this 引用

final 参数在 JBC 中不存在，因此可以重新分配。任何参数（包括 this 引用）仅存储在 JVM 内的一个简单数组中，这允许在索引 0 内重新分配 this 引用。单一方法框架。

重新分配final字段

只要在构造函数中分配了final字段，重新分配该值甚至根本不分配值都是合法的。因此，以下两个构造函数是合法的：

class Foo {
  final int bar;
  Foo() { } // bar == 0
  Foo(Void v) { // bar == 2
    bar = 1;
    bar = 2;
  }
}

对于 static final 字段，甚至允许在 外部重新分配字段
类初始值设定项。

将构造函数和类初始值设定项视为方法

这更多的是一个概念性功能，但构造函数在 JBC 中的处理方式与普通方法没有任何不同。只有 JVM 的验证程序才能确保构造函数调用另一个合法的构造函数。除此之外，构造函数必须称为 ，类初始值设定项称为 ，这只是 Java 命名约定。除了这种差异之外，方法和构造函数的表示是相同的。正如 Holger 在评论中指出的那样，您甚至可以定义具有除 void 之外的返回类型的构造函数或带有参数的类初始值设定项，即使无法调用这些方法。

创建不对称记录*。

创建记录时，

record Foo(Object bar) { }

javac 将生成一个类文件，其中包含名为 bar 的单个字段、名为 bar() 的访问器方法以及采用单个 Object 的构造函数。代码>.此外，还添加了 bar 的记录属性。通过手动生成记录，可以创建不同的构造函数形状，以跳过该字段并以不同的方式实现访问器。同时，仍然可以使反射 API 相信该类代表实际记录。

调用任何超级方法（Java 1.1 之前）

但是，这仅适用于 Java 版本 1 和 1.1。在 JBC 中，方法总是在显式目标类型上分派。这意味着

class Foo {
  void baz() { System.out.println("Foo"); }
}

class Bar extends Foo {
  @Override
  void baz() { System.out.println("Bar"); }
}

class Qux extends Bar {
  @Override
  void baz() { System.out.println("Qux"); }
}

可以实现 Qux#baz 来调用 Foo#baz，同时跳过 Bar#baz。虽然仍然可以定义显式调用来调用直接超类之外的另一个超级方法实现，但这在 1.1 之后的 Java 版本中不再有任何效果。在 Java 1.1 中，此行为是通过设置 ACC_SUPER 标志来控制的，该标志将启用仅调用直接超类的实现的相同行为。

定义对同一个类中声明的方法的非虚拟调用

在 Java 中，不可能定义类

class Foo {
  void foo() {
    bar();
  }
  void bar() { }
}

class Bar extends Foo {
  @Override void bar() {
    throw new RuntimeException();
  }
}

上面的代码总是会导致 RuntimeException当在 Bar 实例上调用 foo 时。无法定义 Foo::foo 方法来调用 Foo它自己的 bar 方法>。由于 bar 是非私有实例方法，因此调用始终是虚拟的。然而，使用字节码，我们可以定义调用以使用 INVOKESPECIAL 操作码，该操作码将 Foo::foo 中的 bar 方法调用直接链接到 < code>Foo 的版本。此操作码通常用于实现超级方法调用，但您可以重用该操作码来实现所描述的行为。

细粒度类型注释

在 Java 中，注释是根据注释声明的 @Target 应用的。使用字节码操作，可以独立于该控件定义注释。此外，例如，即使 @Target 注释适用于两个元素，也可以在不注释参数的情况下注释参数类型。

为类型或其成员定义任何属性

在 Java 语言中，只能为字段、方法或类定义注释。在 JBC 中，您基本上可以将任何信息嵌入到 Java 类中。然而，为了利用这些信息，您可以不再依赖Java类加载机制，而是需要自己提取元信息。

溢出并隐式分配 byte、short、char 和 boolean 值

后者原语类型在 JBC 中通常是未知的，但仅为数组类型或字段和方法描述符定义。在字节码指令中，所有命名类型都占用 32 位空间，这允许将它们表示为 int。官方规定，字节码中仅存在 int、float、long 和 double 类型，它们都需要显式转换JVM 验证器的规则。

不释放监视器

synchronized 块实际上由两条语句组成，一条用于获取监视器，一条用于释放监视器。在 JBC 中，您无需释放即可获取它。

注意：在最近的 HotSpot 实现中，这会导致方法末尾出现 IllegalMonitorStateException，或者如果方法本身因异常而终止，则会导致隐式释放。

向类型初始值设定项添加多个 return 语句

在 Java 中，即使像这样的简单类型初始值设定项也是

class Foo {
  static {
    return;
  }
}

非法的。在字节代码中，类型初始值设定项被视为与任何其他方法一样，即可以在任何地方定义返回语句。

创建不可约循环

Java 编译器将循环转换为 Java 字节代码中的 goto 语句。此类语句可用于创建不可约循环，而 Java 编译器绝不会这样做。

定义递归 catch 块

在 Java 字节代码中，您可以定义一个块：

try {
  throw new Exception();
} catch (Exception e) {
  <goto on exception>
  throw Exception();
}

在 Java 中使用 synchronized 块时，会隐式创建类似的语句，其中释放监视器时出现任何异常返回释放此监视器的指令。通常，此类指令不应发生异常，但如果发生异常（例如已弃用的ThreadDeath），监视器仍将被释放。

调用任何默认方法

Java 编译器需要满足几个条件才能允许调用默认方法：

1. 该方法必须是最具体的方法（不得被由任何类型，包括超级类型）。
2. 默认方法的接口类型必须由调用默认方法的类直接实现。但是，如果接口B扩展了接口A，但没有重写A中的方法，则仍然可以调用该方法。

对于 Java 字节码，只有第二个条件才有效。然而，第一个是无关紧要的。

在不是 this 的实例上调用 super 方法

Java 编译器只允许在 this 的实例上调用 super（或接口默认）方法>。然而，在字节代码中，也可以在相同类型的实例上调用 super 方法，类似于以下内容：

class Foo {
  void m(Foo f) {
    f.super.toString(); // calls Object::toString
  }
  public String toString() {
    return "foo";
  }
}

访问合成成员

在 Java 字节代码中，可以直接访问合成成员。例如，请考虑在以下示例中如何访问另一个 Bar 实例的外部实例：

class Foo {
  class Bar { 
    void bar(Bar bar) {
      Foo foo = bar.Foo.this;
    }
  }
}

对于任何合成字段、类或方法来说通常都是如此。

定义不同步的泛型类型信息

虽然 Java 运行时不处理泛型类型（在 Java 编译器应用类型擦除之后），但此信息仍然作为元信息附加到已编译的类并可供访问通过反射 API。

验证器不会检查这些元数据String编码值的一致性。因此，可以定义与擦除不匹配的通用类型的信息。因此，以下断言可能为真：

Method method = ...
assertTrue(method.getParameterTypes() != method.getGenericParameterTypes());

Field field = ...
assertTrue(field.getFieldType() == String.class);
assertTrue(field.getGenericFieldType() == Integer.class);

此外，签名可以定义为无效，从而引发运行时异常。当第一次访问信息时会抛出此异常，因为它是延迟评估的。 （类似于带有错误的注释值。）

仅为某些方法附加参数元信息

Java 编译器允许在使用 parameter 编译类时嵌入参数名称和修饰符信息标志已启用。然而，在 Java 类文件格式中，此信息是按方法存储的，这使得只能为某些方法嵌入此类方法信息成为可能。

搞乱你的 JVM

例如，在 Java 字节码中，你可以定义调用任何类型的任何方法。通常，如果类型不知道这样的方法，验证器会抱怨。但是，如果您在数组上调用未知方法，我在某些 JVM 版本中发现了一个错误，验证程序将错过此错误，并且一旦调用指令，您的 JVM 将完成。虽然这很难说是一个特性，但从技术上来说，这是 javac 编译的 Java 无法实现的。 Java 有某种双重验证。第一个验证由 Java 编译器应用，第二个验证由 JVM 在加载类时应用。通过跳过编译器，您可能会发现验证器验证中的弱点。不过，这只是一个笼统的说法，而不是一个功能。

没有外部类时注释构造函数的接收者类型

从 Java 8 开始，内部类的非静态方法和构造函数可以声明接收者类型并注释这些类型。顶级类的构造函数无法注释其接收者类型，因为它们大多数不声明接收者类型。

class Foo {
  class Bar {
    Bar(@TypeAnnotation Foo Foo.this) { }
  }
  Foo() { } // Must not declare a receiver type
}

然而，由于 Foo.class.getDeclaredConstructor().getAnnotatedReceiverType() 确实返回表示 Foo 的 AnnotatedType，因此可以包含 Foo 的类型注释code>Foo 的构造函数直接位于类文件中，这些注释稍后由反射 API 读取。

使用未使用/遗留的字节码指令

既然其他人命名了它，我也将包括它。 Java 以前通过 JSR 和 RET 语句使用子例程。为此，JBC 甚至知道自己的返回地址类型。然而，子例程的使用确实使静态代码分析过于复杂，这就是不再使用这些指令的原因。相反，Java 编译器会重复它编译的代码。然而，这基本上创建了相同的逻辑，这就是为什么我并不真正认为它能实现不同的目标。同样，您可以添加 Java 编译器也不使用的 NOOP 字节码指令，但这也不会真正让您实现新的目标。正如上下文中所指出的，这些提到的“功能指令”现在已从合法操作码集中删除，这确实使它们不再是一个功能。

Answer 2

据我所知，Java 6 支持的字节码中没有任何主要功能不能从 Java 源代码访问。造成这种情况的主要原因显然是 Java 字节码是根据 Java 语言设计的。

然而，有一些功能不是由现代 Java 编译器产生的：

• ACC_SUPER 标志：

  这是一个可以在类上设置的标志，并指定如何为此类处理 invokespecial 字节码的特定极端情况。它由所有现代 Java 编译器设置（其中“现代”是 >= Java 1.1，如果我没记错的话），并且只有古代 Java 编译器生成未设置此设置的类文件。该标志仅出于向后兼容的原因而存在。请注意，从 Java 7u51 开始，由于安全原因，ACC_SUPER 被完全忽略。

• jsr/ret 字节码。

  这些字节码用于实现子例程（主要用于实现finally块）。它们自 Java 6 起不再生成。不推荐使用它们的原因是它们使静态验证变得非常复杂，而没有带来太大的好处（即使用的代码几乎总是可以通过正常的跳转重新实现，而开销很小）。

• 一个类中有两个仅返回类型不同的方法。

  Java 语言规范不允许同一类中有两个方法，仅其返回类型不同（即相同的名称、相同的参数列表，...）。然而 JVM 规范没有这样的限制，因此一个类文件可以包含两个这样的方法，只是没有办法使用普通的 Java 编译器生成这样的类文件。 这个答案中有一个很好的示例/解释。

Answer 3

以下是一些可以在 Java 字节码中完成但不能在 Java 源代码中完成的功能：

• 从方法中抛出已检查异常而不声明该方法抛出该异常。已检查异常和未检查异常是仅由 Java 编译器而不是 JVM 检查的东西。因此，例如 Scala 可以从方法中抛出已检查的异常，而无需声明它们。尽管对于 Java 泛型，有一种名为 sneaky throw 的解决方法。< /p>

• 类中有两个方法，仅返回类型不同，如 Joachim 的回答：Java 语言规范不允许同一类中的两个方法不同仅在它们的返回类型中（即相同的名称，相同的参数列表，...）。然而 JVM 规范没有这样的限制，因此一个类文件可以包含两个这样的方法，只是没有办法使用普通的 Java 编译器生成这样的类文件。 这个答案中有一个很好的示例/解释。

Answer 4

• GOTO 可以与标签一起使用来创建您自己的控制结构（for while 等除外）
• 您可以覆盖 this 方法内的局部变量
• 结合这两者，您可以创建创建尾部调用优化的字节码（我在 中执行此操作JCompilo）

作为相关点，您可以获得使用调试编译时方法的参数名称（Paranamer 通过读取字节码来执行此操作

Answer 5

也许本文档中的第7A节很有趣，尽管它是关于字节码陷阱而不是字节码功能。

Answer 6

在Java语言中，构造函数中的第一条语句必须是对超类构造函数的调用。字节码没有这个限制，而是规则是在访问成员之前必须为该对象调用超类构造函数或同一类中的另一个构造函数。这应该允许更多的自由，例如：

• 创建另一个对象的实例，将其存储在局部变量（或堆栈）中并将其作为参数传递给超类构造函数，同时仍保留该变量中的引用以供其他使用。
• 根据条件调用不同的其他构造函数。这应该是可能的：如何有条件地调用不同的构造函数在Java中？

我还没有测试过这些，所以如果我错了，请纠正我。

Answer 7

您可以使用字节码（而不是纯 Java 代码）来生成无需编译器即可加载和运行的代码。许多系统都有 JRE 而不是 JDK，如果您想动态生成代码，生成字节代码可能会更好（如果不是更容易的话），而不是必须先编译 Java 代码才能使用。

Answer 8

当我还是一名 I-Play 人员时，我编写了一个字节码优化器（它旨在减少 J2ME 应用程序的代码大小）。我添加的一项功能是能够使用内联字节码（类似于 C++ 中的内联汇编语言）。我设法通过使用 DUP 指令来减小作为库方法一部分的函数的大小，因为我需要该值两次。我还有零字节指令（如果您正在调用一个采用 char 的方法并且您想传递一个 int，您知道不需要进行强制转换，我添加了 int2char(var) 来替换 char(var) ，它将删除i2c 指令减少了代码的大小。支持浮点）。

Answer 9

在 Java 中，如果您尝试使用受保护的方法（或任何其他减少访问权限）覆盖公共方法，您会收到错误：“尝试分配较弱的访问权限”。如果您使用 JVM 字节码执行此操作，验证程序就可以使用它，并且您可以通过父类调用这些方法，就好像它们是公共的一样。