Java 使用StdDeserializer Jackson 2.5处理多态

我有三个从一个超类（SensorData）继承的类

我希望根据参数将json输入转换为此类之一。我正在尝试使用Jackson StdDeserializer并创建一个自定义反序列化程序

@Component
public class SensorDataDeserializer extends StdDeserializer<SensorData> {

    private static final long serialVersionUID = 3625068688939160875L;

    @Autowired
    private SensorManager sensorManager;

    private static final String discriminator = "name";

    public SensorDataDeserializer() {
        super(SensorData.class);
        SpringBeanProvider.getInstance().autowireBean(this);
    }

    @Override
    public SensorData deserialize(JsonParser parser,
            DeserializationContext context) throws IOException,
            JsonProcessingException {
        ObjectMapper mapper = (ObjectMapper) parser.getCodec();
        ObjectNode root = (ObjectNode) mapper.readTree(parser);
        ObjectNode sensor = (ObjectNode) root.get("data");
        String type = root.get(discriminator).asText();
        Class<? extends SensorData> clazz = this.sensorManager
                .getCachedSensorsMap().get(type).sensorDataClass();
        if (clazz == null) {
            // TODO should throw exception
            return null;
        }
        return mapper.readValue(sensor.traverse(), clazz);
    }
}

输入示例

{
    "name":"temperature",
    "data": {
        "value":20
    }
}

我只包含stacktrace来显示映射程序再次调用反序列化程序。出现nullPointerException的原因是，当第二次调用ObjectMapper时，输入是

"value":20

因此，会抛出一个异常，因为我们没有确定类型的信息，也没有检查输入是否正确

如果可能的话，我想避免使用JsonSubTypes和JsonTypeInfo

提前谢谢

---

部分解

在我的例子中，SensorData被包装在其他类（ServiceData）中

类服务数据{
@JsonDeserialize（使用=SensorDataDeserializer.class）
列出传感器；
}

所以，我去掉了SensorData类中的JsonDeserializer，并将其放在字段中以避免循环。这个解决方案不是最好的，但对我来说，它对我有帮助。但是如果这个类没有封装在另一个类中，我们仍然有同样的问题

请注意，如果您有一个集合，并且使用JsonDeserialize对该字段进行注释，则必须处理所有集合。这是修改 就我而言

 @Component
 public class SensorDataDeserializer extends StdDeserializer<List<SensorData>> {

      private static final long serialVersionUID = 3625068688939160875L;

      @Autowired
      private SensorManager sensorManager;

      private static final String discriminator = "name";

      public SensorDataDeserializer() {
           super(SensorData.class);
            SpringBeanProvider.getInstance().autowireBean(this);
      }

      @Override
      public List<SensorData> deserialize(JsonParser parser,
                DeserializationContext context) throws IOException,
                JsonProcessingException {
           try {
                ObjectMapper mapper = (ObjectMapper) parser.getCodec();
                ArrayNode root = (ArrayNode) mapper.readTree(parser);
                int size = root.size();
                List<SensorData> sensors = new ArrayList<SensorData>();
                for (int i = 0; i < size; ++i) {
                     ObjectNode sensorHead = (ObjectNode) root.get(i);
                     ObjectNode sensorData = (ObjectNode) sensorHead.get("data");
                     String tag = sensorHead.get(discriminator).asText();
                     Class<? extends SensorData> clazz = this.sensorManager
                               .getCachedSensorsMap().get(tag).sensorDataClass();
                     if (clazz == null) {
                          throw new InvalidJson("unbound sensor");
                     }
                     SensorData parsed = mapper.readValue(sensorData.traverse(),
                               clazz);
                     if (parsed == null) {
                          throw new InvalidJson("unbound sensor");
                     }
                     sensors.add(parsed);
                }
                return sensors;
           } catch (Throwable e) {
                throw new InvalidJson("invalid data");
           }

      }
 }

@组件
公共类SensorDataDeserializer扩展StdDeserializer{
私有静态最终长serialVersionUID=36250688939160875L；
@自动连线
私人传感器管理器传感器管理器；
私有静态最终字符串鉴别器=“名称”；
公共SensorDataDeserializer（）{
super（SensorData.class）；
SpringBeanProvider.getInstance（）.autowireBean（这个）；
}
@凌驾
公共列表反序列化（JsonParser，
反序列化上下文）引发IOException，
JsonProcessingException{
试一试{
ObjectMapper映射器=（ObjectMapper）parser.getCodec（）；
ArrayNode根=（ArrayNode）映射器.readTree（解析器）；
int size=root.size（）；
列出传感器=新的ArrayList（）；
对于（int i=0；i类为什么不直接使用
@JsonTypeInfo
？多态处理是它的特定用例

在这种情况下，您可能希望使用以下内容：

@JsonTypeInfo(use=Id.NAME, include=As.PROPERTY, property="name")
@JsonSubTypes({ HumiditySensorData.class, ... }) // or register via mapper
public abstract class SensorData { ... }

@JsonTypeName("temperature")
public class TemperaratureSensorData extends SensorData {
   public TemperaratureSensorData(@JsonProperty("data") JsonNode data) {
     // extract pieces out
  }
}

它将处理从“name”到子类型的解析，将“data”的内容绑定为
JsonNode
（或者，如果您愿意，可以使用
Map
或
Object
或任何匹配的类型）.
因为我不想把@JsonTypeName放在所有的子类型中，但是你帮助我，搜索关于@JsonTypeInfo的信息，我发现我可以用@JsonDeserialize注释一个字段，避免将它放在超类中，所以我能够打破这个循环，这不是最好的解决方案，但现在它仍然有效。无论如何，谢谢你对于回答，它对我帮助很大，我不能投票支持你，因为我没有足够的声誉：（好的。仅供将来参考，还有一种方法可以避免使用
@JsonTypeName
，使用
SimpleModule.registerSubtypes（NamedType…subtypes）
--
NamedType
允许指定子类型使用的名称。以防万一其他人可能正在寻找类似的解决方案。很高兴您解决了这个问题！
class ServiceData {
    @JsonDeserialize(using = SensorDataDeserializer.class)
    List<SensorData> sensors;

}

 @Component
 public class SensorDataDeserializer extends StdDeserializer<List<SensorData>> {

      private static final long serialVersionUID = 3625068688939160875L;

      @Autowired
      private SensorManager sensorManager;

      private static final String discriminator = "name";

      public SensorDataDeserializer() {
           super(SensorData.class);
            SpringBeanProvider.getInstance().autowireBean(this);
      }

      @Override
      public List<SensorData> deserialize(JsonParser parser,
                DeserializationContext context) throws IOException,
                JsonProcessingException {
           try {
                ObjectMapper mapper = (ObjectMapper) parser.getCodec();
                ArrayNode root = (ArrayNode) mapper.readTree(parser);
                int size = root.size();
                List<SensorData> sensors = new ArrayList<SensorData>();
                for (int i = 0; i < size; ++i) {
                     ObjectNode sensorHead = (ObjectNode) root.get(i);
                     ObjectNode sensorData = (ObjectNode) sensorHead.get("data");
                     String tag = sensorHead.get(discriminator).asText();
                     Class<? extends SensorData> clazz = this.sensorManager
                               .getCachedSensorsMap().get(tag).sensorDataClass();
                     if (clazz == null) {
                          throw new InvalidJson("unbound sensor");
                     }
                     SensorData parsed = mapper.readValue(sensorData.traverse(),
                               clazz);
                     if (parsed == null) {
                          throw new InvalidJson("unbound sensor");
                     }
                     sensors.add(parsed);
                }
                return sensors;
           } catch (Throwable e) {
                throw new InvalidJson("invalid data");
           }

      }
 }

@JsonTypeInfo(use=Id.NAME, include=As.PROPERTY, property="name")
@JsonSubTypes({ HumiditySensorData.class, ... }) // or register via mapper
public abstract class SensorData { ... }

@JsonTypeName("temperature")
public class TemperaratureSensorData extends SensorData {
   public TemperaratureSensorData(@JsonProperty("data") JsonNode data) {
     // extract pieces out
  }
}