Java修炼终极指南:135 处理上下文特定反序列化过滤器

JDK 17通过实现JEP 415增强了反序列化过滤器的功能，引入了所谓的过滤器工厂。实际上，根据上下文，过滤器工厂可以动态决定对流使用哪些过滤器。

按应用程序应用过滤器工厂 如果我们想对单个应用程序的运行应用过滤器工厂，我们可以依赖于jdk.serialFilterFactory系统属性。在不触及代码的情况下，我们在命令行上使用此系统属性，如下例所示：

java -Djdk.serialFilterFactory=FilterFactoryName YourApp

FilterFactoryName是过滤器工厂的完全限定名，它是一个公共类，可以被应用程序类加载器访问，并且它在第一次反序列化之前被设置。

将过滤器工厂应用于进程中的所有应用程序 要将过滤器工厂应用于进程中的所有应用程序，我们应该遵循两个步骤（同样，我们不触及应用程序代码）：

1. 以编辑器打开（例如，记事本，写字板）java.security文件。在JDK 6-8中，此文件位于$JAVA_HOME/lib/security/java.security，而在JDK 9+中，位于$JAVA_HOME/conf/security/java.security。
2. 编辑此文件，将过滤器工厂添加到jdk.serialFilterFactory安全属性。

通过ObjectInputFilter.Config应用过滤器工厂 或者，可以通过ObjectInputFilter.Config直接在代码中设置过滤器工厂，如下所示：

ObjectInputFilter.Config
  .setSerialFilterFactory(FilterFactoryInstance);   

FilterFactoryInstance参数是过滤器工厂的实例。这个过滤器工厂将被应用于当前应用程序的所有流。

实现过滤器工厂 过滤器工厂实现为BinaryOperator<ObjectInputFilter>。apply(ObjectInputFilter current, ObjectInputFilter next)方法提供了当前过滤器和下一个或请求的过滤器。为了看看它是如何工作的，让我们假设我们有以下三个过滤器：

public final class Filters {
  private Filters() {
    throw new AssertionError("Cannot be instantiated");
  }
  // ...（之前的allowMelonFilter和rejectMuskmelonFilter方法）
  public static ObjectInputFilter packageFilter() {
    return ObjectInputFilter.Config.createFilter(
        "modern.challenge.*;!*");
  }
}

Filters.allowMelonFilter()被设置为流全局过滤器，如下所示：

ObjectInputFilter.Config.setSerialFilter(
  Filters.allowMelonFilter());      

Filters.rejectMuskmelonFilter()被设置为流特定过滤器，如下所示：

Melon melon = new Melon("Melon", 2400);
// 序列化
byte[] melonSer = Converters.objectToBytes(melon);
// 反序列化
Melon melonDeser = (Melon) Converters.bytesToObject(
  melonSer, Filters.rejectMuskmelonFilter());

在过滤器工厂中设置Filters.packageFilter()，如下所示：

public class MelonFilterFactory implements
       BinaryOperator<ObjectInputFilter> {
  @Override
  public ObjectInputFilter apply(
        ObjectInputFilter current, ObjectInputFilter next) {
    System.out.println();
    System.out.println("Current filter: " + current);
    System.out.println("Requested filter: " + next);
    if (current == null && next != null) {           
      return ObjectInputFilter.merge(
          next, Filters.packageFilter());
    }
    return ObjectInputFilter.merge(next, current);
  }
}

在任何反序列化发生之前，通过ObjectInputFilter.Config设置MelonFilterFactory：

MelonFilterFactory filterFactory = new MelonFilterFactory();       
ObjectInputFilter.Config
                 .setSerialFilterFactory(filterFactory);    

现在一切都已就绪，让我们看看发生了什么。apply()方法被调用了两次。第一次调用是在创建ObjectInputStream ois时，我们得到以下输出：

Current filter: null
Requested filter: predicate(modern.challenge.Filters$Lambda$4/0x0000000801001800@ba8a1dc, ifTrue: ALLOWED, ifFalse: REJECTED)

当前过滤器为null，请求的过滤器是Filters.allowMelonFilter()。由于当前过滤器为null且请求的过滤器不为空，我们决定返回一个过滤器，作为合并请求的过滤器状态与Filters.packageFilter()状态的结果。

第二次调用apply()方法是在Converters.bytesToObject(byte[] bytes, ObjectInputFilter filter)中调用ois.setObjectInputFilter(filter)时。我们有以下输出：

Current filter: merge(predicate(modern.challenge.Filters$Lambda$4/0x0000000801001800@ba8a1dc, ifTrue: ALLOWED, ifFalse:REJECTED), modern.challenge.*;!*)
Requested filter: predicate(modern.challenge.Filters$Lambda$10/0x0000000801002a10@484b61fc, ifTrue: REJECTED, ifFalse:UNDECIDED)

这次，当前和请求的过滤器都不为空，所以我们再次合并它们的状态。最后，所有过滤器都成功通过，反序列化发生。