Эквивалент XSLT для JSON
есть XSLT эквивалент для JSON? Что-то, что позволит мне делать преобразования на JSON, как XSLT делает с XML.
23 ответов
интересная идея. Некоторые поиски в Google произвели несколько интересных страниц, в том числе:
- an контур о том, как такой инструмент "jsonT" может быть реализован, и некоторые загружаемые файлы
- некоторые обсуждение этой реализации
- компания возможно, реализовали что-то подходящее
надеюсь, что это помогает.
попробовать толчек. Это библиотека преобразования JSON в JSON, написанная на Java.
Он был создан специально, потому что мы не хотели играть в игру "JSON -> XML -> XSLT -> XML -> JSON", и использование шаблона для любого достаточно сложного преобразования недостижимо.
XSLT эквиваленты для JSON-список кандидатов (инструментов и спецификаций)
инструменты
-
XSLT
можно использовать XSLT для JSON С целью fn: json-to-xml.
в этом разделе описаны средства, позволяющие обрабатывать данные JSON с помощью XSLT.
-
jq не последний коммит Май 12, 2018
jq не это как sed для данных JSON - вы можете использовать его для среза, фильтрации, отображения и преобразования структурированных данных с той же легкостью, что sed, awk, grep и друзья позволяют вам играть с текстом. Существуют пакеты установки для разных ОС.
-
jj последний коммит Mar 2, 2018
JJ-это утилита командной строки, которая обеспечивает быстрый и простой способ получения или обновления значений из документов JSON. Он питается от GJSON и SJSON под капюшон.
-
fx последний коммит Мар 20, 2018
инструмент обработки JSON командной строки
- не нужно изучать новый синтаксис
- Обычный JavaScript
- форматирование и подсветка
- автономный бинарных
-
jsawk последний коммит Mar 4, 2015
Jsawk похож на awk, но для JSON. Вы работаете с массивом объектов JSON, считанных из stdin, фильтруете их с помощью JavaScript для создания массива результатов, который печатается в stdout.
-
в JSON Последний Коммит Mar 3, 2017
json-это быстрый инструмент CLI для работы с JSON. Это однофайловый узел.сценарий js без внешних деп (кроме узла.сам в JS).
-
jl Последний Коммит Apr 10, 2018
jl ("JSON lambda") - это крошечный функциональный язык для запроса и управления JSON.
-
йет Последний Коммит Mar 13, 2017
тесты могут использоваться как docu https://github.com/pasaran/yate/tree/master/tests
-
в JSON преобразования Последний Коммит Дек 1, 2017
обеспечивает рекурсивный, подход сопоставления шаблонов к преобразованию данных JSON. Преобразования определяются как набор правил, которые соответствуют структуре объекта JSON. При совпадении правило выдает преобразованные данные, при необходимости рекурсивно Преобразуя дочерние объекты.
-
jsonpath-object-transform Последний Коммит Янв 18, 2017
извлекает данные из объектного литерала с помощью JSONPath и генерирует новые объекты на основе шаблона.
-
толчек Последний Коммит Май 1, 2018
библиотека преобразования JSON в JSON, написанная на Java, где "спецификация" для преобразования сама является документом JSON.
-
Грон Последний Коммит Апр 5, 2018
сделать JSON greppable! gron преобразует JSON в дискретные назначения, чтобы упростить grep для того, что вы хотите и увидеть абсолютный "путь" к нему. Это облегчает исследование API, которые возвращают большие капли JSON, но имеют ужасную документацию.
-
сшивание Последний Коммит Sep 16, 2013
сшивание-это библиотека JavaScript, которая позволяет форматировать XSLT для объектов JSON. Вместо использования механизма шаблонов JavaScript и шаблонов text/html, сшивание дает возможность использовать загруженные шаблоны XSLT асинхронно с Ajax, а затем кэшируется на стороне клиента-для анализа ваших источников данных JSON.
-
json-e Последний Коммит 22 Мая 2018
JSON-e-это система параметризации структуры данных для встраивания контекста в объекты JSON. Основная идея состоит в том, чтобы рассматривать структуру данных как "шаблон" и преобразовывать ее, используя другую структуру данных в качестве контекста, для получения выходных данных структура.
технические характеристики:
-
JsonPointer
указатель JSON определяет синтаксис строки для определения определенного значения в документе обозначения объектов JavaScript (JSON).
-
помощью jsonpath
выражения JSONPath всегда ссылаются на структуру JSON так же, как выражение XPath используется в сочетании с XML документ
-
JSPath
JSPath для JSON похож на XPath для XML."
-
JSONiq
основным источником вдохновения для JSONiq является XQuery, который до сих пор был доказан успешным и продуктивным языком запросов для полуструктурированных данных
XSLT поддерживает JSON, как видно наhttp://www.w3.org/TR/xslt-30/#json
XML использует угловые скобки для токенов-разделителей, JSON использует фигурные скобки, квадратные скобки, ... Т. е. Меньшее количество сравнений распознавания маркеров XML означает, что он оптимизирован для декларативного преобразования, тогда как больше сравнений, таких как оператор switch, по соображениям скорости предполагают спекулятивное предсказание ветви, для которого полезен императивный код на языках сценариев. Как прямое следствие, для различные смеси полуструктурированных данных, вы можете проверить производительность движков XSLT и javascript как часть отзывчивых страниц. Для незначительной полезной нагрузки данных преобразования могут работать так же хорошо с JSON без сериализации XML. Решение W3 должно основываться на лучшем анализе.
недавно я нашел инструмент, который мне нравится для укладки JSON:https://github.com/twigkit/tempo. Очень простой в использовании инструмент-на мой взгляд, с ним намного проще работать, чем с XSLT-нет необходимости в запросах XPATH.
jq-легкий и гибкий процессор командной строки JSON
это не на основе шаблонов, как XSLT, но более кратким. например, извлечь name и address поля в массив: [.name, .address]
на учебник проходит через пример преобразования JSON API Twitter (и руководство есть много примеров).
сказать, что отсутствие инструментов предполагает отсутствие необходимости, просто напрашивается вопрос. То же самое можно было бы применить к поддержке X или Y в Linux (зачем беспокоиться о разработке качественных драйверов и/или игр для такой миноритарной ОС? И зачем обращать внимание на ОС, для которой не разрабатываются крупные игровые и аппаратные компании?). Вероятно, люди, которым нужно будет использовать XSLT и JSON, в конечном итоге используют несколько тривиальный обходной путь: преобразование JSON в XML. Но это не оптимальное решение, не так ли?
когда у вас есть собственный формат JSON, и вы хотите отредактировать его "wysywyg" в браузере, XSLT будет более чем адекватным решением проблемы. Выполнение этого с помощью традиционного программирования javascript может стать болью в заднице.
фактически, я реализовал подход "каменного века" к XSLT, используя синтаксический анализ подстрок для интерпретации некоторых основных команд для javascript, таких как вызов шаблона, дочерних процессов и т. д. Конечно, реализация механизма преобразования с объектом JSON очень важна проще, чем реализовать полноценный синтаксический анализатор XML для анализа XSLT. Проблема в том, что для использования шаблонов XML для преобразования объекта JSON необходимо проанализировать XML шаблонов.
чтобы преобразовать объект JSON с помощью XML (или HTML, или текста или чего-либо еще), вам нужно тщательно подумать о синтаксисе и о том, какие специальные символы вам нужно использовать для идентификации команд преобразования. В противном случае вам придется разработать синтаксический анализатор для вашего собственного языка шаблонов. Пройдя по этому пути я могу сказать тебе, что это не красиво.
Update (Nov 12, 2010): через пару недель работы над моим синтаксическим анализатором я смог его оптимизировать. Шаблоны анализируются заранее, а команды хранятся как объекты JSON. Правила преобразования также являются объектами JSON, в то время как код шаблона представляет собой смесь HTML и синтаксиса homebrew, аналогичного коду оболочки. Я смог преобразовать сложный документ JSON в HTML, чтобы сделать редактор документов. Код по 1к строк редактор (это для частного проекта, поэтому я не могу поделиться им) и около 990 строк для кода преобразования JSON (включает команды итерации, простые сравнения, вызов шаблона, сохранение и оценку переменных). Я планирую выпустить его под лицензией MIT. Напишите Мне, если хотите вмешаться.
там сейчас! Я недавно создал библиотеку,в JSON преобразования, именно для этого:
https://github.com/ColinEberhardt/json-transforms
он использует комбинацию JSPath, DSL, смоделированный на XPath, и рекурсивный подход сопоставления шаблонов, вдохновленный непосредственно XSLT.
вот краткий пример. Учитывая следующий объект JSON:
const json = {
"automobiles": [
{ "maker": "Nissan", "model": "Teana", "year": 2011 },
{ "maker": "Honda", "model": "Jazz", "year": 2010 },
{ "maker": "Honda", "model": "Civic", "year": 2007 },
{ "maker": "Toyota", "model": "Yaris", "year": 2008 },
{ "maker": "Honda", "model": "Accord", "year": 2011 }
]
};
здесь трансформация:
const jsont = require('json-transforms');
const rules = [
jsont.pathRule(
'.automobiles{.maker === "Honda"}', d => ({
Honda: d.runner()
})
),
jsont.pathRule(
'.{.maker}', d => ({
model: d.match.model,
year: d.match.year
})
),
jsont.identity
];
const transformed = jsont.transform(json, rules);
который выводит следующее:
{
"Honda": [
{ "model": "Jazz", "year": 2010 },
{ "model": "Civic", "year": 2007 },
{ "model": "Accord", "year": 2011 }
]
}
это преобразование состоит из трех правил. Первый соответствует любому автомобилю, который сделан Honda, испуская объект с Honda Свойства, затем рекурсивно соответствовать. Второе правило соответствует любому объекту с maker собственность, вывода model и year свойства. Финал-это преобразование идентичности, которое рекурсивно соответствует.
Как еще один новый ответ на старый вопрос, я предлагаю посмотреть DefiantJS. Это не XSLT эквивалентно для JSON, это is XSLT для JSON. Раздел" Шаблоны " документации включает в себя следующий пример:
<!-- Defiant template -->
<script type="defiant/xsl-template">
<xsl:template name="books_template">
<xsl:for-each select="//movie">
<xsl:value-of select="title"/><br/>
</xsl:for-each>
</xsl:template>
</script>
<script type="text/javascript">
var data = {
"movie": [
{"title": "The Usual Suspects"},
{"title": "Pulp Fiction"},
{"title": "Independence Day"}
]
},
htm = Defiant.render('books_template', data);
console.log(htm);
// The Usual Suspects<br>
// Pulp Fiction<br>
// Independence Day<br>
недавно я написал свою собственную небольшую библиотеку вокруг этого, которая пытается оставаться как можно ближе к
5.1 модель обработки (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model
как можно (как я мог бы в любом случае), в нескольких строках кода JavaScript.
вот несколько не совсем тривиальных примеров использования...
1. JSON-to-some-markup:
Скрипка: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10
(вдохновленный D. 1 пример документа (XSLT REC) https://www.w3.org/TR/xslt#section-Document-Example)
где это:
var D1document = {
type: "document", title: [ "Document Title" ],
"": [
{ type: "chapter", title: [ "Chapter Title" ],
"": [
{ type: "section", title: [ "Section Title" ],
"": [
{ type: "para", "": [ "This is a test." ] },
{ type: "note", "": [ "This is a note." ] }
] },
{ type: "section", title: [ "Another Section Title" ],
"": [
{ type: "para", "": [ "This is ", { emph: "another" }, " test." ] },
{ type: "note", "": [ "This is another note." ] }
] }
] }
] };
var D1toHTML = { $: [
[ [ function(node) { return node.type === "document"; } ],
function(root) {
return "<html>\r\n\
<head>\r\n\
<title>\r\n\
{title}\r\n".of(root) + "\
</title>\r\n\
</head>\r\n\
<body>\r\n\
{*}".of(root[""].through(this)) + "\
</body>\r\n\
</html>";
}
],
[ [ function(node) { return node.type === "chapter"; } ],
function(chapter) {
return " <h2>{title}</h2>\r\n".of(chapter) + "{*}".of(chapter[""].through(this));
}
],
[ [ function(node) { return node.type === "section"; } ],
function(section) {
return " <h3>{title}</h3>\r\n".of(section) + "{*}".of(section[""].through(this));
}
],
[ [ function(node) { return node.type === "para"; } ],
function(para) {
return " <p>{*}</p>\r\n".of(para[""].through(this));
}
],
[ [ function(node) { return node.type === "note"; } ],
function(note) {
return ' <p class="note"><b>NOTE: </b>{*}</p>\r\n'.of(note[""].through(this));
}
],
[ [ function(node) { return node.emph; } ],
function(emph) {
return "<em>{emph}</em>".of(emph);
}
]
] };
console.log(D1document.through(D1toHTML));
... дает:
<html>
<head>
<title>
Document Title
</title>
</head>
<body>
<h2>Chapter Title</h2>
<h3>Section Title</h3>
<p>This is a test.</p>
<p class="note"><b>NOTE: </b>This is a note.</p>
<h3>Another Section Title</h3>
<p>This is <em>another</em> test.</p>
<p class="note"><b>NOTE: </b>This is another note.</p>
</body>
</html>
и
2. JSON-to-JSON:
Скрипка:https://jsfiddle.net/YSharpLanguage/ppfmmu15/10
где это:
// (A "Company" is just an object with a "Team")
function Company(obj) {
return obj.team && Team(obj.team);
}
// (A "Team" is just a non-empty array that contains at least one "Member")
function Team(obj) {
return ({ }.toString.call(obj) === "[object Array]") &&
obj.length &&
obj.find(function(item) { return Member(item); });
}
// (A "Member" must have first and last names, and a gender)
function Member(obj) {
return obj.first && obj.last && obj.sex;
}
function Dude(obj) {
return Member(obj) && (obj.sex === "Male");
}
function Girl(obj) {
return Member(obj) && (obj.sex === "Female");
}
var data = { team: [
{ first: "John", last: "Smith", sex: "Male" },
{ first: "Vaio", last: "Sony" },
{ first: "Anna", last: "Smith", sex: "Female" },
{ first: "Peter", last: "Olsen", sex: "Male" }
] };
var TO_SOMETHING_ELSE = { $: [
[ [ Company ],
function(company) {
return { some_virtual_dom: {
the_dudes: { ul: company.team.select(Dude).through(this) },
the_grrls: { ul: company.team.select(Girl).through(this) }
} }
} ],
[ [ Member ],
function(member) {
return { li: "{first} {last} ({sex})".of(member) };
} ]
] };
console.log(JSON.stringify(data.through(TO_SOMETHING_ELSE), null, 4));
... дает:
{
"some_virtual_dom": {
"the_dudes": {
"ul": [
{
"li": "John Smith (Male)"
},
{
"li": "Peter Olsen (Male)"
}
]
},
"the_grrls": {
"ul": [
{
"li": "Anna Smith (Female)"
}
]
}
}
}
3. XSLT против JavaScript:
эквивалент JavaScript...
XSLT 3.0 REC раздел 14.4 пример: группировка узлов на основе общих значений
(at:http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1)
Cf. https://www.w3.org/TR/xslt-30/#grouping-examples
где...
var cities = [
{ name: "Milano", country: "Italia", pop: 5 },
{ name: "Paris", country: "France", pop: 7 },
{ name: "München", country: "Deutschland", pop: 4 },
{ name: "Lyon", country: "France", pop: 2 },
{ name: "Venezia", country: "Italia", pop: 1 }
];
/*
Cf.
XSLT 3.0 REC Section 14.4
Example: Grouping Nodes based on Common Values
https://www.w3.org/TR/xslt-30/#grouping-examples
*/
var output = "<table>\r\n\
<tr>\r\n\
<th>Position</th>\r\n\
<th>Country</th>\r\n\
<th>City List</th>\r\n\
<th>Population</th>\r\n\
</tr>{*}\r\n\
</table>".of
(
cities.select().groupBy("country")(function(byCountry, index) {
var country = byCountry[0],
cities = byCountry[1].select().orderBy("name");
return "\r\n\
<tr>\r\n\
<td>{position}</td>\r\n\
<td>{country}</td>\r\n\
<td>{cities}</td>\r\n\
<td>{population}</td>\r\n\
</tr>".
of({ position: index + 1, country: country,
cities: cities.map(function(city) { return city.name; }).join(", "),
population: cities.reduce(function(sum, city) { return sum += city.pop; }, 0)
});
})
);
... дает:
<table>
<tr>
<th>Position</th>
<th>Country</th>
<th>City List</th>
<th>Population</th>
</tr>
<tr>
<td>1</td>
<td>Italia</td>
<td>Milano, Venezia</td>
<td>6</td>
</tr>
<tr>
<td>2</td>
<td>France</td>
<td>Lyon, Paris</td>
<td>9</td>
</tr>
<tr>
<td>3</td>
<td>Deutschland</td>
<td>München</td>
<td>4</td>
</tr>
</table>
4. JSONiq и на JavaScript:
эквивалент JavaScript...
Примеры Использования JSONiq Раздел 1.1.2. Группировка запросов для JSON
(at:https://jsfiddle.net/YSharpLanguage/hvo24hmk/3)
Cf. http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping
где...
/*
1.1.2. Grouping Queries for JSON
http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping
*/
var sales = [
{ "product" : "broiler", "store number" : 1, "quantity" : 20 },
{ "product" : "toaster", "store number" : 2, "quantity" : 100 },
{ "product" : "toaster", "store number" : 2, "quantity" : 50 },
{ "product" : "toaster", "store number" : 3, "quantity" : 50 },
{ "product" : "blender", "store number" : 3, "quantity" : 100 },
{ "product" : "blender", "store number" : 3, "quantity" : 150 },
{ "product" : "socks", "store number" : 1, "quantity" : 500 },
{ "product" : "socks", "store number" : 2, "quantity" : 10 },
{ "product" : "shirt", "store number" : 3, "quantity" : 10 }
];
var products = [
{ "name" : "broiler", "category" : "kitchen", "price" : 100, "cost" : 70 },
{ "name" : "toaster", "category" : "kitchen", "price" : 30, "cost" : 10 },
{ "name" : "blender", "category" : "kitchen", "price" : 50, "cost" : 25 },
{ "name" : "socks", "category" : "clothes", "price" : 5, "cost" : 2 },
{ "name" : "shirt", "category" : "clothes", "price" : 10, "cost" : 3 }
];
var stores = [
{ "store number" : 1, "state" : "CA" },
{ "store number" : 2, "state" : "CA" },
{ "store number" : 3, "state" : "MA" },
{ "store number" : 4, "state" : "MA" }
];
var nestedGroupingAndAggregate = stores.select().orderBy("state").groupBy("state")
( function(byState) {
var state = byState[0],
stateStores = byState[1];
byState = { };
return (
(
byState[state] =
products.select().orderBy("category").groupBy("category")
( function(byCategory) {
var category = byCategory[0],
categoryProducts = byCategory[1],
categorySales = sales.filter(function(sale) {
return stateStores.find(function(store) { return sale["store number"] === store["store number"]; }) &&
categoryProducts.find(function(product) { return sale.product === product.name; });
});
byCategory = { };
return (
(
byCategory[category] =
categorySales.select().orderBy("product").groupBy("product")
( function(byProduct) {
var soldProduct = byProduct[0],
soldQuantities = byProduct[1];
byProduct = { };
return (
(
byProduct[soldProduct] =
soldQuantities.reduce(function(sum, sale) { return sum += sale.quantity; }, 0)
),
byProduct
);
} ) // byProduct()
),
byCategory
);
} ) // byCategory()
),
byState
);
} ); // byState()
... дает:
[
{
"CA": [
{
"clothes": [
{
"socks": 510
}
]
},
{
"kitchen": [
{
"broiler": 20
},
{
"toaster": 150
}
]
}
]
},
{
"MA": [
{
"clothes": [
{
"shirt": 10
}
]
},
{
"kitchen": [
{
"blender": 250
},
{
"toaster": 50
}
]
}
]
}
]
также полезно преодолеть ограничения jsonpath wrt. запрос против оси предка, как поднято это так вопрос (и других, конечно).
например, как получить скидку на продуктовый товар, зная его идентификатор бренда, в
{
"prods": [
{
"info": {
"rate": 85
},
"grocery": [
{
"brand": "C",
"brand_id": "984"
},
{
"brand": "D",
"brand_id": "254"
}
],
"discount": "15"
},
{
"info": {
"rate": 100
},
"grocery": [
{
"brand": "A",
"brand_id": "983"
},
{
"brand": "B",
"brand_id": "253"
}
],
"discount": "20"
}
]
}
?
возможный вариант:
var products = {
"prods": [
{
"info": {
"rate": 85
},
"grocery": [
{
"brand": "C",
"brand_id": "984"
},
{
"brand": "D",
"brand_id": "254"
}
],
"discount": "15"
},
{
"info": {
"rate": 100
},
"grocery": [
{
"brand": "A",
"brand_id": "983"
},
{
"brand": "B",
"brand_id": "253"
}
],
"discount": "20"
}
]
};
function GroceryItem(obj) {
return (typeof obj.brand === "string") && (typeof obj.brand_id === "string");
}
// last parameter set to "true", to grab all the "GroceryItem" instances
// at any depth:
var itemsAndDiscounts = [ products ].nodeset(GroceryItem, true).
map(
function(node) {
var item = node.value, // node.value: the current "GroceryItem" (aka "$.prods[*].grocery[*]")
discount = node.parent. // node.parent: the array of "GroceryItem" (aka "$.prods[*].grocery")
parent. // node.parent.parent: the product (aka "$.prods[*]")
discount; // node.parent.parent.discount: the product discount
// finally, project into an easy-to-filter form:
return { id: item.brand_id, discount: discount };
}
),
discountOfItem983;
discountOfItem983 = itemsAndDiscounts.
filter
(
function(mapped) {
return mapped.id === "983";
}
)
[0].discount;
console.log("Discount of #983: " + discountOfItem983);
... что дает:
Discount of #983: 20
' HTH,
Я действительно устал от огромного количества JavaScript-шаблонов и всех их встроенных HTML-шаблонов,разных стилей разметки и т. д. и решил создайте небольшую библиотеку это позволяет форматировать XSLT для структур данных JSON. Не ракетостроение в любом случае-это просто JSON, проанализированный в XML, а затем отформатированный с помощью документа XSLT. Это тоже быстро, не так быстро, как движки шаблонов JavaScript в Chrome, но в большинстве других браузеров это, по крайней мере, так же быстро в качестве альтернативы JS engine для больших структур данных.
Я использую Camel route umarshal(xmljson) -> to(xlst) -> маршал (xmljson). Достаточно эффективно (хотя и не на 100% идеально), но просто, если вы уже используете Camel.
не слишком уверен, что это необходимо, и для меня отсутствие инструментов говорит об отсутствии необходимости. JSON лучше всего обрабатывается как объекты (как это делается в JS в любом случае), и вы обычно используете язык самих объектов для выполнения преобразований (Java для объектов Java, созданных из JSON, то же самое для Perl, Python, Perl, c#, PHP и так далее). Просто с обычными заданиями (или set, get), циклами и так далее.
Я имею в виду, XSLT - это просто другой язык, и одна из причин, по которой он нужен, заключается в том, что XML не является обозначения объектов и, следовательно, объекты языков программирования не являются точными (импеданс между иерархической xml-моделью и объектами/структурами).
очень возможно преобразовать JSON с помощью XSLT: вам нужен десериализатор JSON2SAX и сериализатор SAX2JSON.
пример кода на Java: http://www.gerixsoft.com/blog/json/xslt4json
Yate (https://github.com/pasaran/yate) специально разработан после XSLT, имеет JPath (естественный эквивалент XPath для JS), компилируется в JavaScript и имеет довольно историю производственного использования. Это практически недокументировано, но чтения образцов и тестов должно быть достаточно.
Почему бы вам не преобразовать JSON в XML с помощью Сведения Г-На Преобразовательных Установок, преобразуйте его с помощью XSLT, а затем измените его на JSON, используя то же самое.
для рабочего каракули / доказательства концепции подхода к использованию чистого JavaScript вместе со знакомым и декларативным шаблоном за соответствующими выражениями XSLT и рекурсивными шаблонами см. https://gist.github.com/brettz9/0e661b3093764f496e36
(аналогичный подход может быть принят для JSON.)
обратите внимание, что демо также полагается на закрытие выражений JavaScript 1.8 для удобства выражения шаблонов в Firefox (по крайней мере, до ES6 краткая форма для методов может быть реализована).
отказ от ответственности: это мой собственный код.
Я написал адаптер dom для моего JSON-фреймворка на основе jackson давным-давно. Он использует nu.библиотека сом. Результирующее дерево dom работает со средствами java xpath и xslt. Я сделал несколько вариантов реализации, которые довольно просты. Например, корневой узел всегда называется "root", массивы входят в узел ol с элементами Li sub (например, в html), а все остальное - просто подузел с примитивным значением или другим объектом узел.
использование:
JsonObject sampleJson = sampleJson();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
один подход еще не задан, чтобы использовать генератор парсера для создания парсера в XSLT, который анализирует JSON и производит вывод XML.
одним из вариантов, который часто упоминается на конференциях XML, является генератор синтаксического анализатора ReX (http://www.bottlecaps.de/rex/) - хотя полностью недокументированы на сайте, рецепты доступны при поиске.
возможно использование XSLT с JSON. Версия 3 XPath(3.1) XSLT(3.0) и XQuery(3.1) каким-то образом поддерживает JSON. Это, по-видимому, доступно в коммерческой версии Saxon и может в какой-то момент быть включено в версию HE. https://www.saxonica.com/html/documentation/functions/fn/parse-json.html
-
что я ожидал бы от альтернативного решения:
Я хотел бы иметь возможность ввода JSON для извлечения соответствующий набор данных и вывод JSON или текста.
доступ к произвольным свойствам и оценить значения
поддержка условной логики
Я хотел бы, чтобы сценарии преобразования были внешними из инструмента, текстовыми и, желательно, часто используемым языком.
потенциальная альтернатива?
интересно, может ли SQL быть подходящим альтернатива. https://docs.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server
было бы неплохо, если бы альтернативный инструмент мог обрабатывать JSON и XML https://docs.microsoft.com/en-us/sql/relational-databases/xml/openxml-sql-server
Я еще не пытался преобразовать скрипты XSLT, которые я использую в SQL, или полностью оценил эту опцию, но я надеюсь изучить ее в ближайшее время. Пока только некоторые мысли.