使用Spring数据在ElasticSearch中使用通用JsonNode存储文档

Question

我想使用以下实体的Spring Data将未指定的json有效载荷数据存储在Elasticsearch索引中

    @Document(indexName = "message")
    public class Message {
    
        @Id
        private String id;
        private JsonNode payload;

        //getters and setters here
    }

有效负载各不相同，需要以通用的方式存储，也可以轻松地再次加载，这就是为什么我想在这里使用JsonNode。

将写入具有“id”的文档，但字段“payload”为空。

当我在Kibana中查找写入索引的文档时，它如下所示：

_class:
    com.tryout.Message
payload:
id:
    30243006-0844-4438-a7f0-db93518b340f
_id:
    30243006-0844-4438-a7f0-db93518b340f
_type:
    _doc
_index:
    message
_score:
    0 

在索引映射中，“有效负载”也没有创建，它看起来像这样：

{
  "mappings": {
    "_doc": {
      "properties": {
        "_class": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        },
        "id": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword",
              "ignore_above": 256
            }
          }
        }
      }
    }
  }
}

有没有办法存储我的通用有效载荷？

（我使用弹性v7.9.2

Answer 1

在将spring data elastic search版本升级到4之后，我遇到了这个问题，不幸的是，我没有找到一个明确的答案。阅读spring data elasticsearch文档，我发现：

从4.0版开始，仅使用元对象映射，基于Jackson的映射器不再可用，使用MappingElasticsearchConverter。

经过几天的探索，我终于用这种方式解决了我的问题，我希望它能帮助其他人。

P. s： JsonNode可以包含jsonArray或JsonObject，所以这两种数据类型应该在读/写时处理。

class JsonElasticSearchConverter extends MappingElasticsearchConverter {

    private CustomConversions conversions = new ElasticsearchCustomConversions(Collections.emptyList());

    CustomElasticSearchConverter(MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext) {
        super(mappingContext);
        setConversions(conversions);
    }

    CustomElasticSearchConverter(MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext, GenericConversionService conversionService) {
        super(mappingContext, conversionService);
        setConversions(conversions);
    }

    @Override
    protected <R> R readValue(@Nullable Object source, ElasticsearchPersistentProperty property,
                              TypeInformation<R> targetType) {

        if (source == null) {
            return null;
        }

        if (targetType.getType() == JsonNode.class) {
            return (R) mapStoredValueToJsonNode(source);
        }

        return super.readValue(source, property, targetType);
    }

    @Override
    protected Object getWriteComplexValue(ElasticsearchPersistentProperty property, TypeInformation<?> typeHint, Object value) {
        if (typeHint.getType() == JsonNode.class) {
            return getWriteJsonNodeValue(value);
        }
        return super.getWriteComplexValue(property, typeHint, value);
    }

    private JsonNode mapStoredValueToJsonNode(Object source) {
        JsonNode jsonNode = null;
        ObjectMapper mapper = new ObjectMapper();
        if (source instanceof ArrayList) {
            ArrayNode array = mapper.valueToTree(source);
            jsonNode = mapper.valueToTree(array);
        }
        if (source instanceof HashMap) {
            jsonNode = mapper.convertValue(source, JsonNode.class);
        }
        return jsonNode;
    }

    private Object getWriteJsonNodeValue(Object value) {
        JsonNode jsonNode = null;
        ObjectMapper mapper = new ObjectMapper();
        if (value instanceof ObjectNode)
            try {
                jsonNode = mapper.readTree(value.toString());
            } catch (IOException shouldNotHappened) {
                //log.warn("This error should not happened" + shouldNotHappened.getMessage());
            }
        else if (value instanceof ArrayNode) {
            ArrayNode array = mapper.valueToTree(value);
            jsonNode = mapper.valueToTree(array);
        }
        return jsonNode;
    }
}