.NET JSON Parser nach Java Import

Halli Hallo

Da es sowohl Java als auch .NET betrifft, stell ich die Frage dennoch mal hier, da das der Ausgangspunkt der ganzen Problematik ist.
Und zwar hab ich ein JSON File, generiert von http://james.newtonking.com/json, welches ich nach Java importieren muss bzw. die Infos herauslesen muss. Hat da jemand einen Wink bzw. Tipp wie man das angehen muss oder nach was man da googlen sollte?
Problem aktuell ist, das ich die .NET Klassen ja irgendwie nach Java bekommen muss wenn ich es auslesen will. Und da scheitert es schon. Denn was auf C Seite reingestopft wird, ist ein IDictionary Objekt. Wie bilde ich das in Java ab?

Das JSON sieht so aus, falls das irgendwie helfen sollte.

{
  "$id": "1",
  "$type": "System.Collections.Generic.Dictionary`2[[WarehouseDim.Model.AisleType, WarehouseDim],[WarehouseDim.Model.Solution, WarehouseDim]], mscorlib",
  "WarehouseDim.Model.AisleType": {
    "$id": "2",
    "$type": "WarehouseDim.Model.Solution, WarehouseDim",
    "PartToAisleDistributions": [
      {
        "$id": "3",
        "$type": "WarehouseDim.Model.PartToAisleDistribution, WarehouseDim",
        "ProductClassAllocation": {
          "$id": "4",
          "$type": "System.Collections.Generic.Dictionary`2[[WarehouseDim.Model.ProductClass, WarehouseDim],[System.Int32, mscorlib]], mscorlib",
          "WarehouseDim.Model.ProductClass": 4000
        },
        "TotalFields": 4000,
        "TotalAmount": 6000,

in Kürze:
Im Kern werden die erzeugten Klassen aus dem Source Projekt einfach nur durch den Parser gejagdt und am Ende kommt das entsprechende File raus. Meine Aufgabe ist nun das wieder in Java verfügbar zu machen.

Für alle Hilfen bin ich sehr dankbar

Grüße

Ich würde mich ganz schnell von dem Gedanken verabschieden - diese Klassen in Java nachzubauen/iwie hinzufrickeln. Eine Schnittstelle sollte Plattformunabhängig sein - und in deinem Fall ist diese das nicht. Was ist wenn du jetzt noch mit anderen Sprachen diese Informationen nutzen möchtest?

Also solltest du die ganze Geschichte schonmal auf der C#-Seite überdenken. Bau dir eine zu serialisierende Klasse, welche ohne .Net-Klassen auskommt (also am besten nur primitive Datentypen verwenden) oder nur solche die deine Bibliothek auch behandeln kann. Auf der Java-Seite baust du dir dann nur noch eine Klasse zusammen, welche mit dieser Schnittstelle arbeiten kann (für das deserialisieren kannst du z.B. gson nutzen).

ich weiß nicht was du anders machst, aber in den Samples schaut das Ergebnis der serialisierung eines Dictonarys auch iwie anders aus: http://james.newtonking.com/json/help/index.html?topic=html/Samples.htm

Inwiefern meinst du das mit der Klasse welche mit meiner Bibliothek umgehen kann? Sprich Objekte serialisieren/derserialisieren mit denen der Parser selbst etwas anfangen kann, also keine selbstgebauten Klassen?

Ansonsten hab ich sowas schon fast vermutet das es eine heiden Arbeit ist bzw. kein guter Plan und unmöglich. Hatte da nämlihc schonmal mit Wrapper Libs wie Javonet herumerxperiment oder auch ob man mit irgendeiner Art des Marshallings wieder zu den Ursprungsklassen kommt. Aber alles mit dem selben, nicht vorhandenem, Ergebnis.
Die Serialisierung wurde soweit ich weiß nochmal angepasst, es werden Referenzen/Circles eingebaut, id’s vergeben. Auf die Schnelle kann ich das aber auch nicht mit genaueren Infos belegen da ich den nicht selbst gebaut habe.

Ich meine damit, dass dein JSON-Code später keinen Bezug zu einer Klasse mehr haben sollte. Über eine Schnittstelle sollten nur Daten übertragen werden, so dass man einfach daran andocken kann. Wenn da jetzt aber ein Bezug zu einer Klasse vorhanden ist - dann gibst du ja eine konkrete Implementierung vor und schaffst somit wieder Abhängigkeiten.

Aber kann es sein, dass es sich bei den Feldern mit dem $-präfix um Meta-infos handelt? Also wenn du in Java diese Felder einfach ignorieren würdest, würdest du dann deine komplette Datenmenge erhalten?

Ah, so meinst du das. Ja das macht natürlich Sinn und wäre zu begrüßen. Die MetaInfos können nicht weggelassen werden, da z.B. über die id’s später Referenzen hergestellt werden wenn Objekte doppelt vorhanden sind.

Di Felder ($id,…) können ja bleiben. Auf Java-Seite kannst du diese ja ignorieren. Wichtig ist halt nur, dass du alle Daten überträgst - welche du auch später auf Java-Seite brauchst. Und den Eintrag $type kannst du ja ignorieren. Ein Übernehmen der Klasse ist auch nicht Notwendig - du nutzt einfach die entsprechenden Gegenstücke in der jeweiligen Sprache. In Java wäre dann halt eine [japi]Map[/japi] dein Gegenstück zum Dictonary.

Im Endeffekt muss ich dann also wieder die Klassen nachJava übertragen. Wenn da beispielsweise “MyRandomClass” serialisiert wurde, muss ich dann auch erstmal in Java nachbauen, oder nicht? Dann noch die jeweiligen Annotations und es sollte in der Theorie finktionieren.

Gibt auch Möglichkeiten ohne eigene Klasse mit json zu arbeiten - aber hier würde ich dann doch eine Klasse für die Schnittstelle schreiben/nachbauen. Damit kannst du wesentlich angenehmer arbeiten. Und gson z.B. ignoriert auch Felder die nicht zur Klasse passen - also sollten dir diese Metainfos ($id, $type) keine Probleme bereiten.

Thx schonmal soweit, ich schau mal wie weit ich komme. Ansonsten meld ich mich nochmal