java - 在 Java 中分离协议(protocol)解析器和处理程序

Question

我正在使用一个简单的二进制协议(protocol)。每个数据包由 10 个字节组成。第一个字节指定数据包类型。使用了很多(~50)种数据包类型。

我想为此协议(protocol)编写一个独立于数据包处理的通用解析器。所以解析器应该检测数据包类型并将数据放入适当的数据包类的实例中，该类包含协议(protocol)数据。例如，考虑以下类:当解析器检测到数据包类型 1 --> new Type1() 并读取原始字节并设置温度和湿度。对于数据包类型 2 和所有其他数据包类型也是如此。

class Packet {
  byte[] raw;
}

class Type1 extends Packet {
  int temperature;
  int humidity;
}

class Type2 extends Packet {
  DateTime sunrise;
  DateTime sunset;
}

由于数据包类型如此之多，但每个应用程序只使用很少的类型，因此应该可以在解析开始之前注册某些类型。所有其他数据包类型都将被忽略。

我计划为每种数据包类型配备一个 PacketParser。可能，我还需要每种类型的处理程序类。例如:

abstract class Type1Parser {
  abstract void handle(Type1 packet);
}

class Type1Parser extends PacketParser {
  //how to use/set handler? how to pass packet to handler?
  static public Type1Handler type1Handler = null;

  @override
  void parse(Packet input) {
    if(type1Handler == null)
      return;
    Type1 packet = new Type1(input);
    packet.temperature = byteToInt(input.raw, 0, 3);
    packet.humidity = byteToInt(input.raw, 4, 7);

    type1Handler.handle(packet);
  }
}

如何连接解析器和处理程序？以上是一种天真的方法:程序需要实现Type1Handler，并设置静态变量Type1Parser.type1Handler。

然后主解析器看起来像这样:

class MainParser {
   Type1Parser type1 = new Type1Parser();
   Type2Parser type2 = new Type2Parser();
   ...
   void parse(byte[] packet) {
     switch(packet[0]) {
       case 1: type1.parse(packet); break;
       case 2: type2.parse(packet); break;
       ...
     }
   }
}

然而，这似乎是 1) 很多非常相似的代码行 2) 很多开销，因为所有数据包解析器都被实例化并且为每个数据包调用 parse()，即使没有注册处理程序也是如此。

有什么改进此代码的想法吗？

注意:解析应该对程序透明。解析代码应该留在“解析库”中。所以理想情况下，该程序只“知道”类 TypeXHandler 和 TypeX。

Answer 1

这个设计问题没有完美的答案，我不想假装我的答案是完美的，但希望我对这个问题的直觉方法能教给你一些你不知道的东西!我看到您的代码中主要缺少的组件是泛型:

public interface Parser<T extends Packet> {
  T parse(Packet packet);
}

public interface Handler<T extends Packet> {
  void handle(T packet);
}

这样，您可以使用惰性静态初始化来管理您知道的数据包类型。我不会在这里完整地充实代码，而是给你一个想法:

public class TypeRegistry {
  private static Map<Integer, TypeHandlerBundle<?>> typeHandlerBundles;

  static <T> register(int typeNum, Class<T> clazz, Parser<T> parser, Handler<T> handler) {
    // Make bundle, add to map
  }

  ... void parse(Packet packet) {
    if (typeHandlerBundles.containsKey((int) packet[0])) {
      TypeHandlerBundle<?> bundle = typeHandlerBundles.get((int) packet[0]);
      bundle.parseAndHandle(packet);
    }
  } 
}

public class TypeHandlerBundle<T extends Packet> {
  ...
  private final Parser<T> parser;
  private final Handler<T> handler;

  ... void parseAndHandle(Packet packet) {
    T parsedPacket = parser.parse(packet);
    handler.handle(parsedPacket);
  }
}

...

public class Type1Processor {
  static {
    TypeRegistry.register(1, Type1.class, TYPE1_PARSER, TYPE1_HANDLER);
  }

  // Definition of constants, implementation, etc.
  // ...
}

===

我省略的东西:限定符、较低级别的实现、错误检查、同步、主要方法等。根据您的设置，静态初始化可能不是调用 TypeRegistry.register 的正确方法>，因此您可以改为考虑列出类的属性文件(呃，但有其优点)，或者在您的 main 方法中使用硬编码的调用序列。

因为 Parser 和 Handler 在这里是函数式接口(interface)，不要忘记你可以用 lambdas 来实现它们!您可以通过这种方式节省大量代码行。