面白いアイデア。 Googleで検索すると、次のような興味のあるページがいくつか見つかりました。
- outline そのような「jsonT」ツールの実装方法、および 一部のダウンロード
- いくつか その実装の議論
- 適切なものを実装している可能性があります
お役に立てれば。
JOLT を試してください。 Javaで記述されたJSONからJSONへの変換ライブラリです。
「JSON-> XML-> XSLT-> XML-> JSON」ゲームをプレイしたくなかったために作成され、十分に複雑な変換にテンプレートを使用することは維持できません。
JSONに相当するXSLT-候補のリスト（ツールと仕様）
道具
- XSLT （
XSLT for JSON を fn：json-to-xml の目的で使用できます。
このセクションでは、XSLTを使用してJSONデータを処理できる機能について説明します。
- jq
jqはJSONデータのsedに似ています-sed、awk、grep、friendsがテキストで遊ぶのと同じように簡単に構造化データをスライス、フィルター、マッピング、変換できます。異なるOS用のインストールパッケージがあります。
- jj
JJは、JSONドキュメントから値を取得または更新するための高速で簡単な方法を提供するコマンドラインユーティリティです。これは、GJSONとSJSONによって内部で動作します。
- fx （
コマンドラインJSON処理ツール
- 新しい構文を学ぶ必要はありません
- プレーンJavaScript
- 書式設定と強調表示
- スタンドアロンバイナリ
- jl
jl（ "JSON lambda"）は、JSONを照会および操作するための小さな関数型言語です。
- JOLT
Javaで記述されたJSONからJSONへの変換ライブラリ。変換の「仕様」自体はJSONドキュメントです。
- gron （
JSONをgreppableにします！ gronはJSONを個別の割り当てに変換して、必要なものをgrepし、その絶対パスを確認しやすくします。 JSONの大きな塊を返すが、ひどいドキュメントがあるAPIの探索を容易にします。
- json （
jsonはJSONを操作するための高速なCLIツールです。これは、単一のファイルnode.jsスクリプトであり、外部の依存関係はありません（node.js自体を除く）。
- json-e
JSON-eは、JSONオブジェクトにコンテキストを埋め込むためのデータ構造パラメーター化システムです。中心的なアイデアは、データ構造を「テンプレート」として扱い、別のデータ構造をコンテキストとして使用して変換し、出力データ構造を生成することです。
- JSLT
JSLTは、JSONの完全なクエリおよび変換言語です。言語設計は、jq、XPath、およびXQueryに触発されています。
- json-transforms最終コミット2017年12月1日
JSONデータを変換するための再帰的なパターンマッチングアプローチを提供します。変換は、JSONオブジェクトの構造に一致する一連のルールとして定義されます。一致が発生すると、ルールは変換されたデータを出力し、オプションで子オブジェクトを変換するために再帰します。
- jsawk最終コミット2015年3月4日
Jsawkはawkに似ていますが、JSON用です。 stdinから読み取ったJSONオブジェクトの配列を操作し、JavaScriptを使用してそれらをフィルター処理して、stdoutに出力される結果配列を生成します。
- yate最終コミット2017年3月13日
テストはdocuとして使用できます https://github.com/pasaran/yate/tree/master/tests
- jsonpath-object-transform （最終コミット2017年1月18日
JSONPathを使用してオブジェクトリテラルからデータを取得し、テンプレートに基づいて新しいオブジェクトを生成します。
- ステープル留め最終コミット2013年9月16日
ステープルは、JSONオブジェクトのXSLTフォーマットを有効にするJavaScriptライブラリです。 JavaScriptテンプレートエンジンとtext/htmlテンプレートを使用する代わりに、StaplingはXSLTテンプレート（Ajaxと非同期にロードされ、クライアント側にキャッシュされる）を使用してJSONデータソースを解析する機会を提供します。
仕様：
- JsonPointer
JSONポインターは、JavaScript Object Notation（JSON）文書内の特定の値を識別するためのストリング構文を定義します。
- JsonPath
JSONPath式は、XPath式がXMLドキュメントと組み合わせて使用されるのと同じ方法で、常にJSON構造を参照します
- JSPath
JSONのJSPathは、XMLのXPathに似ています。」
- JSONiq
JSONiqの背後にあるインスピレーションの主なソースはXQueryです。これは、これまでに半構造化データの成功した生産的なクエリ言語であることが証明されています。
XSLTは http://www.w3.org/TR/xslt-30/#json で見られるJSONをサポートしています
XMLはデリミタトークンにangularブラケットを使用し、JSONは中括弧、角括弧を使用します。 XMLのトークン認識比較が少ないということは、宣言的な変換に最適化されていることを意味しますが、switch文のように、速度上の理由から、スクリプト言語の命令コードが役立つ投機的な分岐予測を想定している比較が多いことを意味します。直接的な結果として、半構造化データのさまざまな組み合わせに対して、レスポンシブページの一部としてXSLTおよびjavascriptエンジンのパフォーマンスをベンチマークすることができます。無視できるデータペイロードの場合、XMLシリアル化なしのJSONでも変換は同様に機能する可能性があります。 W3の決定は、より優れた分析に基づくべきです。
最近、JSONのスタイリングに気に入っているツールを見つけました： https://github.com/twigkit/tempo 。非常に使いやすいツール-私の意見では、XSLTよりも作業がはるかに簡単です-XPATHクエリは不要です。
jsonpath-object-transform をご覧ください
ツールの欠如が必要性の欠如を示唆していると言うことは、ただ質問を懇願することです。 LinuxでのXまたはYのサポートにも同じことが当てはまります（なぜ少数のOS向けに高品質のドライバーやゲームを開発する必要があるのでしょうか？また、大手ゲーム会社やハードウェア会社が開発していないOSに注意を払うのはなぜですか？）おそらく、XSLTとJSONを使用する必要がある人々は、やや些細な回避策を使用することになります。JSONをXMLに変換することです。しかし、それは最適な解決策ではありませんか？
ネイティブJSON形式があり、ブラウザーで「wysywyg」を編集したい場合、XSLTは問題に対する十分な解決策になります。従来のjavascriptプログラミングでこれを行うと、苦痛になります。
実際、XSLTに「石器時代」のアプローチを実装しました。テンプレートの呼び出し、子プロセスなど、JavaScriptの基本的なコマンドを解釈するサブストリング解析を使用しています。 XSLTを解析するための本格的なXMLパーサーの実装。問題は、XMLテンプレートを使用してJSONオブジェクトを変換するには、テンプレートのXMLを解析する必要があることです。
JSONオブジェクトをXML（またはHTML、またはテキストなど）で変換するには、構文と、変換コマンドを識別するために使用する必要がある特殊文字について慎重に検討する必要があります。そうしないと、独自のカスタムテンプレート言語用のパーサーを設計することになります。その道を歩いて、私はそれがきれいではないと言うことができます。
更新（2010年11月12日）：パーサーで数週間作業した後、最適化することができました。テンプレートは事前に解析され、コマンドはJSONオブジェクトとして保存されます。変換ルールもJSONオブジェクトですが、テンプレートコードはHTMLとシェルコードに似た自作の構文が混在しています。複雑なJSONドキュメントをHTMLに変換して、ドキュメントエディターを作成することができました。コードはエディターでは約1K行（共有プロジェクトではないため共有できません）、JSON変換コードでは約990行（反復コマンド、単純な比較、テンプレートの呼び出し、変数の保存と評価を含む）です。 MITライセンスでリリースする予定です。参加したい場合はメールをください。
今があります！私は最近、まさにこの目的のために、ライブラリjson-transformsを作成しました：
https://github.com/ColinEberhardt/json-transforms
JSPath 、XPathでモデル化されたDSL、および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 }
]
}
この変換は、3つのルールで構成されています。最初のものは、ホンダ製のあらゆる自動車と一致し、Hondaプロパティを持つオブジェクトを出力し、その後再帰的に一致します。 2番目のルールは、makerプロパティを持つオブジェクトと一致し、modelプロパティとyearプロパティを出力します。最後は、再帰的に一致するID変換です。
最近、これについて私自身の小さなライブラリを書きました。
5.1処理モデル（XSLT REC）https://www.w3.org/TR/xslt#section-Processing-Model =
可能な限り（とにかく）、JavaScriptコードの数行で。
以下に、完全ではないが些細な使用例をいくつか示します...
1. JSON-to-some-markup：
フィドル： https://jsfiddle.net/YSharpLanguage/kj9pk8oz/1
（D.1ドキュメントの例（XSLT REC）に触発されたhttps://www.w3.org/TR/xslt#section-ドキュメント例 ）
ここで：
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/1
ここで：
// (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例：共通値に基づいたノードのグループ化
（で： 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のクエリのグループ化
（で： https://jsfiddle.net/YSharpLanguage/hvo24hmk/ ）
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の制限を克服するのにも役立ちます。 this SO question （および確かにその他）で発生した、祖先軸に対するクエリ。
たとえば、ブランドIDを知っている食料品の割引を取得する方法
{
"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、
古い質問に対するさらに別の新しい回答として、 DefiantJS をご覧になることをお勧めします。 JSONのXSLTと同等ではなく、それisJSONのXSLT。ドキュメントの「テンプレート」セクションには、次の例が含まれています。
<!-- 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>
膨大な量のJavaScriptテンプレートエンジン、およびそのすべてのインラインHTMLテンプレート、さまざまなマークアップスタイルなどに本当にうんざりしており、XSLTフォーマットを有効にする 小さなライブラリを作成する を決定しましたJSONデータ構造用。決してロケット科学ではありません。XMLに解析され、XSLTドキュメントでフォーマットされたJSONです。これも高速で、ChromeのJavaScriptテンプレートエンジンほど高速ではありませんが、他のほとんどのブラウザでは、少なくとも大規模なデータ構造の代替JSエンジンと同じくらい高速です。
私はCamelルートunmarshal（xml json）-> to（xslt）-> marshal（xmljson）を使用しています。十分に効率的ですが（100％完全ではありませんが）、すでにCamelを使用している場合は簡単です。
Yate（ https://github.com/pasaran/yate ）は、XSLTに特化して設計されており、JPath（JSと同等の自然なXPath）を備え、JavaScriptにコンパイルされ、実稼働での使用の歴史があります。実際には文書化されていませんが、サンプルやテストを読むだけで十分です。
xSLTを使用してJSONを変換することは非常に可能です。JSON2SAXデシリアライザーとSAX2JSONシリアライザーが必要です。
Javaのサンプルコード： http://www.gerixsoft.com/blog/json/xslt4json
JSLT は、XSLTに相当するJSONに非常に近いです。これは、JSON構文で出力の固定部分を記述した後、式を挿入してテンプレートに挿入する値を計算する変換言語です。
例：
{
"time": round(parse-time(.published, "yyyy-MM-dd'T'HH:mm:ssX") * 1000),
"device_manufacturer": .device.manufacturer,
"device_model": .device.model,
"language": .device.acceptLanguage
}
Jacksonの上にあるJavaに実装されています。
まだ提供されていないアプローチの1つは、パーサージェネレーターを使用して、JSONを解析してXML出力を生成するXSLTでパーサーを作成することです。
XMLコンファレンスでよく言及されるオプションの1つは、ReXパーサージェネレーターです（ http://www.bottlecaps.de/rex/ ）-サイトでは完全に文書化されていませんが、検索でレシピを入手できます。
XSLTの一致する式と再帰的なテンプレートの背後にある馴染みのある宣言的なパターンとともに純粋なJavaScriptを利用するアプローチの実際のDoodle/Proof of Conceptについては、 https://Gist.github.com/brettz9/0e661b3093764f496e36 を参照してください=
（JSONについても同様のアプローチが取られる可能性があります。）
デモは、Firefoxでテンプレートを表現するのに便利なJavaScript 1.8式クロージャーにも依存していることに注意してください（少なくともメソッドのES6ショートフォームが実装されるまで）。
免責事項：これは私自身のコードです。
JSON-e にはNode.js、Python、Goの実装があります。
これが必要かどうかはあまりわかりませんが、ツールの不足は必要性の欠如を示唆しています。 JSONはオブジェクトとして処理するのが最適です（とにかくJSで行われる方法）。通常、オブジェクト自体の言語を使用して変換を行います（JSONから作成されたJavaオブジェクトのJava。Perl、Python、Perlでも同じです） 、c＃、PHPなど）。通常の割り当て（または設定、取得）、ループなどだけで。
つまり、XSLTは単なる別の言語であり、必要な理由の1つは、XMLがオブジェクト表記ではないため、プログラミング言語のオブジェクトが完全に適合しないことです（階層型xmlモデルとオブジェクト/構造体の間のインピーダンス）。
Mr。Data Converter を使用してJSONをXMLに変換し、XSLTを使用して変換してから、同じものを使用してJSONに戻しませんか。
私はずっと前に、Jacksonベースのjson処理フレームワーク用のdomアダプターを作成しました。 nu.xomライブラリを使用します。結果のdomツリーは、Java xpathおよびxslt機能で動作します。私は実装をかなり簡単に選択しました。たとえば、ルートノードは常に「ルート」と呼ばれ、配列はliサブ要素（htmlなど）を持つolノードに入り、その他はすべてプリミティブ値を持つサブノードまたは別のオブジェクトノードになります。
使用法：JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
JSONでXSLTを使用できる場合があります。 XPath（3.1）XSLT（3.0）およびXQuery（3.1）のVerson 3は、何らかの方法でJSONをサポートしています。これは商用版のSaxonで利用できるようで、ある時点でHEバージョンに含まれる可能性があります。 https://www.saxonica.com/html/documentation/functions/fn/parse-json.html
-
代替ソリューションに期待すること：
JSONを入力して一致するデータのセットを取得し、JSONまたはTEXTを出力できるようにしたいと思います。
任意のプロパティにアクセスし、値を評価する
条件付きロジックのサポート
変換スクリプトは、ツールの外部にあり、テキストベースで、できれば一般的に使用される言語にする必要があります。
潜在的な代替案？
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に変換しようとしていないか、このオプションをまだ完全に評価していませんが、もっと早く調べたいと思っています。これまでのところ、いくつかの考え。