Канонициализация файлов JSON

Ответ 1

Модуль Python JSON очень полезен из других программ:

generate_json | python -mjson.tool > canonical.json

Ответ 2

Если вы готовы пройти немного накладных расходов, позвонив

gson.toJson(canonicalize(gson.toJsonTree(obj)));

Затем вы можете сделать что-то вроде этого:

protected static JsonElement canonicalize(JsonElement src) {
  if (src instanceof JsonArray) {
    // Canonicalize each element of the array
    JsonArray srcArray = (JsonArray)src;
    JsonArray result = new JsonArray();
    for (int i = 0; i < srcArray.size(); i++) {
      result.add(canonicalize(srcArray.get(i)));
    }
    return result;
  } else if (src instanceof JsonObject) {
    // Sort the attributes by name, and the canonicalize each element of the object
    JsonObject srcObject = (JsonObject)src;
    JsonObject result = new JsonObject();
    TreeSet<String> attributes = new TreeSet<>();
    for (Map.Entry<String, JsonElement> entry : srcObject.entrySet()) {
      attributes.add(entry.getKey());
    }
    for (String attribute : attributes) {
      result.add(attribute, canonicalize(srcObject.get(attribute)));
    }
    return result;
  } else {
    return src;
  }
}

Ответ 3

Это поддерживается в Джексоне:

@JsonPropertyOrder (буквенный = истина)

http://fasterxml.github.io/jackson-annotations/javadoc/2.3.0/com/fasterxml/jackson/annotation/JsonPropertyOrder.html

Ответ 4

Я не пробовал много комбинаций, но кажется, что google-gson хранит порядок атрибутов в JSON.

удалил пример здесь, поскольку он больше не релевантен

Из опыта предыдущих проектов я знаю, что он чрезвычайно настраиваем, например, если базового объекта недостаточно, можно использовать GsonBuilder для создания более сложных адаптеров.

Я, однако, не тестировал это широко с вашим прецедентом, но должно быть просто проверить, имеет ли он ожидаемый результат

UPDATE

вместо того, чтобы использовать SVN/CVS, чтобы проверить, были ли ваши файлы изменены, я обнаружил, что у GSON есть встроенная поддержка версий, которая может или может не обращайтесь к своей проблеме из своих документов:

Несколько версий одного и того же объекта можно сохранить, используя @Начиная с аннотации. Эта аннотация может использоваться для классов, полей и в будущих выпусках Методов. Чтобы использовать эту функцию, вы должны сконфигурировать свой экземпляр Gson, чтобы игнорировать любое поле/объект, который больше, чем номер версии. Если в экземпляре Gson не установлена ​​версия, он будет сериализовать и десериализовать все поля и классы независимо от версии.

UPDATE

Единственное, что я могу придумать, - это разбор ваших внешних файлов с помощью rhino и использования JSON.stringify, чтобы преобразовать обработанный JSON обратно в строку, тогда вы можете быть уверены, что он прошел через один "парсер", и результат не будет отличаться.

Затем вы можете обнаружить любые возможные изменения.

Ответ 5

Библиотека Java с открытым исходным кодом Jackson может приложить определенные усилия для настройки, но способна довольно печатать и имеет довольно аккуратный @JsonPropertyOrder, которая поддерживает буквенный или ручной порядок вывода.

Ответ 6

Ruby 1.9+ поддерживает порядок вставки хэшей, а JSON - 1.9+.

asdf = {'a' => 1, 'b' => 2}
asdf.to_json # => "{\"a\":1,\"b\":2}"

asdf = {'b' => 1, 'a' => 2}
asdf.to_json # => "{\"b\":1,\"a\":2}"

Здесь, как создать "симпатичный" формат:

asdf = {'a' => 1, 'b' => 2}
puts JSON.pretty_generate(asdf)
{
  "a": 1,
  "b": 2
}

asdf = {'b' => 1, 'a' => 2}
irb(main):022:0> puts JSON.pretty_generate(asdf)
{
  "b": 1,
  "a": 2
}

... те же атрибуты вставляются в другом порядке...

Это не имеет большого значения для меня, но я собираюсь сделать снимок.

Поскольку Ruby поддерживает порядок вставки, не слишком важно, какой порядок данных будет, если вы создадите хеш в заданном порядке; Настройте порядок, сортируя ключи и восстанавливая хэш, и передайте это JSON:

require 'json'

puts Hash[{'a' => 1, 'b' => 2}.sort_by{ |a| a }].to_json
=> {"a":1,"b":2}

puts Hash[{'b' => 2, 'a' => 1}.sort_by{ |a| a }].to_json
=> {"a":1,"b":2}

puts Hash[{'b' => 2, 'c' => 3, 'a' => 1}.sort_by{ |a| a }].to_json
=> {"a":1,"b":2,"c":3}

puts Hash[{'b' => 2, 'c' => 3, 'a' => 1}.sort_by{ |a| a }].to_json
=> {"a":1,"b":2,"c":3}

puts Hash[{'a' => 1, 'c' => 3, 'b' => 2}.sort_by{ |a| a }].to_json
=> {"a":1,"b":2,"c":3}

Ответ 7

Здесь простой JSON-кодер в Qt - должен быть относительно легко переработан на Java. Все, что вам действительно нужно сделать, это убедиться, что ключи отсортированы при записи - можете прочитать с другим пакетом JSON.

QString QvJson::encodeJson(const QVariant& jsonObject) {
    QVariant::Type type = jsonObject.type();
    switch (type) {
        case QVariant::Map: 
            return encodeObject(jsonObject);
        case QVariant::List:
            return encodeArray(jsonObject);
        case QVariant::String:
            return encodeString(jsonObject);
        case QVariant::Int:
        case QVariant::Double:
            return encodeNumeric(jsonObject);
        case QVariant::Bool:
            return encodeBool(jsonObject);
        case QVariant::Invalid:
            return encodeNull(jsonObject);
        default:
            return encodingError("encodeJson", jsonObject, ErrorUnrecognizedObject);
    }
}

QString QvJson::encodeObject(const QVariant& jsonObject) {
    QString result("{ ");
    QMap<QString, QVariant> map = jsonObject.toMap();
    QMapIterator<QString, QVariant> i(map);
    while (i.hasNext()) {
        i.next();
        result.append(encodeString(i.key()));

        result.append(" : ");

        result.append(encodeJson(i.value()));

        if (i.hasNext()) {
            result.append(", ");
        }
    }
    result.append(" }");
    return result;
}

QString QvJson::encodeArray(const QVariant& jsonObject) {
    QString result("[ ");
    QList<QVariant> list = jsonObject.toList();
    for (int i = 0; i < list.count(); i++) {
        result.append(encodeJson(list.at(i)));
        if (i+1 < list.count()) {
            result.append(", ");
        }
    }
    result.append(" ]");
    return result;
}

QString QvJson::encodeString(const QVariant &jsonObject) {
    return encodeString(jsonObject.toString());
}

QString QvJson::encodeString(const QString& value) {
    QString result = "\"";
    for (int i = 0; i < value.count(); i++) {
        ushort chr = value.at(i).unicode();
        if (chr < 32) {
            switch (chr) {
                case '\b':
                    result.append("\\b");
                    break;
                case '\f':
                    result.append("\\f");
                    break;
                case '\n':
                    result.append("\\n");
                    break;
                case '\r':
                    result.append("\\r");
                    break;
                case '\t':
                    result.append("\\t");
                    break;
                default:
                    result.append("\\u");
                    result.append(QString::number(chr, 16).rightJustified(4, '0'));
            }  // End switch
        }
        else if (chr > 255) {
            result.append("\\u");
            result.append(QString::number(chr, 16).rightJustified(4, '0'));
        }
        else {
            result.append(value.at(i));
        }
    }
    result.append('"');
    QString displayResult = result;  // For debug, since "result" often doesn't show
    Q_UNUSED(displayResult);
    return result;
}

QString QvJson::encodeNumeric(const QVariant& jsonObject) {
    return jsonObject.toString();
}

QString QvJson::encodeBool(const QVariant& jsonObject) {
    return jsonObject.toString();
}

QString QvJson::encodeNull(const QVariant& jsonObject) {
    return "null";
}

QString QvJson::encodingError(const QString& method, const QVariant& jsonObject, Error error) {
    QString text;
    switch (error) {
        case ErrorUnrecognizedObject: 
            text = QObject::tr("Unrecognized object type");
            break;
    default:
            Q_ASSERT(false);
    }
    return QObject::tr("*** Error %1 in QvJson::%2 -- %3").arg(error).arg(method).arg(text);
}

Ответ 8

Отсортируйте ключи объектов, которые вы сериализуете, перед их выводом. В Ruby 1,9 хеши заказываются по умолчанию; в Ruby 1.8 это не так. Вы можете использовать OrderedHash из active_support, чтобы быть уверенным в любом случае.

Всякий раз, когда вы собираетесь писать данные JSON, сортируйте ключи. Обратите внимание, что в Ruby 1.8 символы не могут быть отсортированы, поэтому вы должны вызвать to_s в своем роде.

require 'rubygems'
require 'json'
require 'active_support/ordered_hash'

obj = {
  :fig => false,
  :bananas => false,
  :apples => true,
  :eggplant => true,
  :cantaloupe => true,
  :dragonfruit => false
}

def sorted_hash(hsh)
  sorted_keys = hsh.keys.sort_by { |k| k.to_s }
  sorted_keys.inject(ActiveSupport::OrderedHash.new) do |o_hsh, k|
    o_hsh[k] = hsh[k]
    o_hsh
  end
end

puts JSON.pretty_generate(obj)
# Could output in any order, depending on version of Ruby
# {
#   "eggplant": true,
#   "cantaloupe": true,
#   "dragonfruit": false,
#   "fig": false,
#   "bananas": false,
#   "apples": true
# }

puts JSON.pretty_generate(sorted_hash(obj))
# Always output in the same order
# {
#   "apples": true,
#   "bananas": false,
#   "cantaloupe": true,
#   "dragonfruit": false,
#   "eggplant": true,
#   "fig": false
# }

Если ваши данные состоят из массива объектов или вложенных объектов, вам нужно создать рекурсивно отсортированные хеши:

nested_obj = {:a => {:d => true, :b => false}, :e => {:k => false, :f => true}, :c => {:z => false, :o => true}}

def recursive_sorted_hash(hsh)
  sorted_keys = hsh.keys.sort_by { |k| k.to_s }
  sorted_keys.inject(ActiveSupport::OrderedHash.new) do |o_hsh, k|
    o_hsh[k] = hsh[k].is_a?(Hash) ? recursive_sorted_hash(hsh[k]) : hsh[k]
    o_hsh
  end
end

puts JSON.pretty_generate(nested_obj)
# Again, could be in any order
# {
#   "a": {
#     "b": false,
#     "d": true
#   },
#   "e": {
#     "f": true,
#     "k": false
#   },
#   "c": {
#     "z": false,
#     "o": true
#   }
# }

puts JSON.pretty_generate(recursive_sorted_hash(nested_obj))
# Even nested hashes are in alphabetical order
# {
#   "a": {
#     "b": false,
#     "d": true
#   },
#   "c": {
#     "o": true,
#     "z": false
#   },
#   "e": {
#     "f": true,
#     "k": false
#   }
# }