我们来观察一下这个过程：

import static java.lang.StringTemplate.RAW;


class Raw {
    public static void main(String[] args) {
        String world = "World";
        System.out.println(RAW."Hello \{world}!");
    }

}

输出结果是 StringTemplate{ fragments = [ "Hello ", "!" ], values = [World] }，
也就是把 "Hello " + world + "!" 里的 "Hello", "!" 给整理到 fragments 里，把依赖的变量值 world = "World" 给整理到了 values 里。

RAW 字节码原理

仔细想想这是个鸡生蛋的问题：RAW 是用来生成 StringTemplate 的，
但是 RAW 它其实是个字符串处理器（StringTemplate.Processor），那么它先需要一个 StringTemplate 的参数才能返回一个 StringTemplate 值。
那么 RAW.process(RAW.process(RAW.process(...))) 的尽头到底是什么？

那当然是编译器从中插的手。

实际上，虽然我们需要 import static java.lang.StringTemplate.RAW; 才能使用 RAW，
但是 RAW."Hello \{world}!" 的编译结果里连 RAW 的影子都看不见。
取而代之的是我们熟悉的 InvokeDynamic 字节码。

不熟悉？继续看吧。（或者也可以看看还在无脑用 StringBuilder？来重温一下字符串拼接吧。）

InvokeDynamic 说到底就分为两步：

1. JVM 自动调用字节码指定的方法来生成一个包装有运算逻辑的 CallSite 对象
2. 当前的以及之后的所有 InvokeDynamic 都会直接调用这个 CallSite 来进行相关的逻辑运算

在 RAW 这个例子里：

1. JVM 调用 java.lang.runtime.TemplateRuntime::newStringTemplate 来生成一个 CallSite，可以看作是 StringTemplate 的工厂对象
2. 之后所有的 RAW."Hello \{world}!" 都会自动使用这个工厂对象来创建，根据不同的 world 值生成不同的 StringTemplate 对象。

我们来手动使用一下：

import java.lang.invoke.CallSite;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.runtime.TemplateRuntime;
import java.lang.StringTemplate;

class RawManual {
    public static void main(String[] args) throws Throwable {
        String world = "World";


        // RAW."Hello \{world}!"
        // 第一步，生成 CallSite
        CallSite factory = TemplateRuntime.newStringTemplate(
            MethodHandles.lookup(),
            "",
            MethodType.methodType(StringTemplate.class, String.class),
            "Hello ",  // <---
            "!"        // <---
        );
        // 第二步，传入不同的 world 值即可生成不同的 StringTemplate
        StringTemplate t = (StringTemplate) factory.dynamicInvoker().invokeExact(world);
        System.out.println(t);
    }
}

输出结果是 StringTemplate{ fragments = [ "Hello ", "!" ], values = [World] }，和上面的 RAW."Hello \{world}!" 的例子一致。

从上面手动使用的代码可以看出，第一步生成的 CallSite 里面保存了字符串模板里面的不变值 "Hello ", "!"，
而可变值通过后面的 invokeExact 传入。
但是，Java 参数传递存在参数数量上限（最多 255 个参数），此时 invokeExact 有可能没办法传递所有的插值
（例如 RAW."\{v1}\{v2}...\{v512}"），此时编译器会使用 TemplateRuntime::newLargeStringTemplate，用数组来传递参数。
个人认为这里还有点优化的空间，这里就不详细介绍了。

FMT: 格式化

FMT 其实就是支持类似 String.format 的字符串处理器。限于目前的语法，现在使用的形式大概是这个样子：

// 需要 import static java.util.FormatProcessor.FMT;
String f = FMT."1.0 + 1.0 = %.9f\{1.0 + 1.0}";

个人感觉有点别扭，但也不是不能用。因为用法和 String.format 一致，这里就不多加介绍了。

想要支持不同国家/语言下的格式的话可以用 FormatProcessor::create 来创建自己的其它字符串处理器。

FMT 字节码原理

从上面 RAW 来看的话，我们也许会猜想这里的字节码应该会是类似 FMT.process(RAW."%.9f\{x + y}") 的形式。
但是，如果你实际去反汇编的话，你会发现代码里一次 FMT.process 的调用都没有。

编译器：我还能变身三次我还能继续优化

还是我们熟悉的 InvokeDynamic 指令。当然，再继续解释就有点无趣了，直接看图吧。