JSON einlesen - Hilfe für Anfänger

[jobo]

Der Ansatz, JSON 'per Hand' zu zerlegen, scheint mir nicht sinnvoll oder viel zu mühevoll.
Ich habe hier ein Beispiel für Postgres SQL gemacht.

https://dbfiddle.uk/?rdbms=postgres_...04c5eefd41b168

Dort werden ein paar Beispieldaten in eine Tabelle eingefügt und zerlegt. Es sind anfangs ein paar Statements aufgeführt, die die grobe Zerlegung zeigen, am Ende dann ein paar "Anwendungsfälle".

Dort im Browser ist es etwas lahm, auf einer normalen DB geht es zumindest mit den Beispieldaten aber flott.

[TiGü]

Ausgehend von Uwes Konsolenprogramm und den richtigen Daten aus #9 aus dem Archiv schnell was zusammengezimmert.
Ganzes Projekt mit Beispieldaten im Anhang als ZIP-Archiv.

Mir ist bewusst, dass in diesem Ansatz die Sendernamen fehlen, da es sich hier um eine 1:1-Umsetzung der Json-Daten handelt.
Die Transformation in das gewünschte Datenformat steht noch aus, da uns dies unbekannt ist TERWI.
Kann aber ggf. durch RTTI geholt werden (https://stackoverflow.com/questions/...ss-at-run-time).
Dies überbleibt dem geneigten Leser als Fingerübung und Hausaufgabe.

Delphi-Quellcode:

program JsonZattoo;

{$APPTYPE CONSOLE}


uses
    System.SysUtils,
    System.IOUtils,
    REST.Json,
    ZattooTypes in 'ZattooTypes.pas';

procedure ParseJson();
var
    Root: TRoot;
    LChannels: TChannels;
    LChannelInfo: TChannelInfo;
    LEPGInfo: TEPGInfo;
    FileContent: string;
    Txt: string;
begin
    FileContent := TFile.ReadAllText('EPG_GUIDE.json');
    Root := TJson.JsonToObject<TRoot>(FileContent);
    try
        LChannels := Root.ChannelContainer.Channels;
        for LChannelInfo in LChannels do
        begin
            for LEPGInfo in LChannelInfo do
            begin
                Writeln('ID: ', LEPGInfo.id);
                Writeln('Title: ', LEPGInfo.title);

                if not LEPGInfo.episode_title.IsEmpty then
                begin
                    Writeln('Episode: ', LEPGInfo.episode_title);
                end;

                if Length(LEPGInfo.genre) > 0 then
                begin
                    Writeln('  Genre(s):');
                    for Txt in LEPGInfo.genre do
                    begin
                        Writeln('    ' + Txt);
                    end;
                end;
                Writeln('--------------------');
            end;
        end;
    finally
        Root.Free;
    end;
end;

begin
    ReportMemoryLeaksOnShutdown := True;
    try
        ParseJson;
    except
        on E: Exception do
                Writeln(E.ClassName, ': ', E.Message);
    end;
    Readln

end.

Delphi-Quellcode:

unit ZattooTypes;

interface

uses
    REST.Json.Types;

type
    TEPGInfo = class
    private
        Fid: Integer;
        [JSONName('t')]
        FTitle: string;
        [JSONName('et')]
        FEpisode_title: string;
        [JSONName('g')]
        FGenre: TArray<string>;
    public
        property id: Integer read Fid write Fid;
        property title: string read FTitle write FTitle;
        property episode_title: string read FEpisode_title write FEpisode_title;
        property genre: TArray<string> read FGenre write FGenre;
    end;

    TChannelInfo = TArray<TEPGInfo>;
    TChannels = TArray<TChannelInfo>;

    TChannelContainer = class
    private
        Fsixx_deutschland: TChannelInfo;
        Fard: TChannelInfo;
        Fdeutschesmusikfernsehen: TChannelInfo;
        F3sat: TChannelInfo;
        function GetChannels: TChannels;
    public
        destructor Destroy; override;

        property Channels: TChannels read GetChannels;

        { // optional, wenn du nur eine Handvoll Sender brauchst und den direkten Zugriff willst, ansonsten per Channels-Property
          property deutschesmusikfernsehen: TChannelInfo read Fdeutschesmusikfernsehen write Fdeutschesmusikfernsehen;
          property ard: TChannelInfo read Fard write Fard;
          property _3sat: TChannelInfo read F3sat write F3sat;
          property sixx_deutschland: TChannelInfo read Fsixx_deutschland write Fsixx_deutschland;
        }
    end;

    TRoot = class
    private
        [JSONName('channels')]
        FChannels: TChannelContainer;
    public
        destructor Destroy; override;
        property ChannelContainer: TChannelContainer read FChannels;
    end;

implementation

destructor TRoot.Destroy;
begin
    FChannels.Free;

    inherited;
end;

destructor TChannelContainer.Destroy;
var
    ChannelInfo: TChannelInfo;
    EPGInfo: TEPGInfo;
begin
    for ChannelInfo in Self.Channels do
    begin
        for EPGInfo in ChannelInfo do
        begin
            EPGInfo.Free;
        end;
    end;
    inherited;
end;

function TChannelContainer.GetChannels: TChannels;
begin
    Result := [Fsixx_deutschland, Fard, Fdeutschesmusikfernsehen, F3sat];
end;

end.

Beispielausgabe:

Code:

ID: 238874757
Title: Charmed - Zauberhafte Hexen
Episode: Vergissmeinnicht
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 239947163
Title: Charmed - Zauberhafte Hexen
Episode: Die Ohnmacht der Drei
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 238874759
Title: Charmed - Zauberhafte Hexen
Episode: Tödliche Liebe
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 238874760
Title: Charmed - Zauberhafte Hexen
Episode: Opfer der Sehnsucht
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 238906082
Title: ZDF-Mittagsmagazin
  Genre(s):
    News
    Magazine
    Society
--------------------
ID: 238906083
Title: Tagesschau
Episode: vom 21.12.2021, 14:00 Uhr
  Genre(s):
    News
    Politics
    Weather
--------------------
ID: 238906084
Title: Rote Rosen
Episode: Folge 3475
  Genre(s):
    Drama
    Soap
--------------------
ID: 238906085
Title: Tagesschau
Episode: vom 21.12.2021, 15:00 Uhr
  Genre(s):
    News
    Politics
    Weather
--------------------
ID: 238906086
Title: Sturm der Liebe
Episode: Folge 3742
  Genre(s):
    Romance & Love
    Soap
--------------------
ID: 238906087
Title: Tagesschau
Episode: vom 21.12.2021, 16:00 Uhr
  Genre(s):
    News
    Politics
    Weather
--------------------
ID: 238906088
Title: Verrückt nach Meer
Episode: Abenteuer am Öresund
  Genre(s):
    Travel
--------------------
ID: 240036356
Title: Das große Wunschkonzert
Episode: Kastelruther Spatzen
  Genre(s):
    Music
--------------------
ID: 240036357
Title: Musiktipps
  Genre(s):
    Music
--------------------
ID: 240036358
Title: Teleshopping
  Genre(s):
    Talk Show
    Home Shopping
--------------------
ID: 240036359
Title: Bianca: Ihre schönsten Lieder
  Genre(s):
    Music
--------------------
ID: 240036360
Title: Musiktipps
  Genre(s):
    Music
--------------------
ID: 240036361
Title: Teleshopping
  Genre(s):
    Talk Show
    Home Shopping
--------------------
ID: 238905942
Title: Von Sibirien nach Japan
Episode: Wildes Kamtschatka
--------------------
ID: 238905944
Title: Von Sibirien nach Japan
Episode: Im Banne der Inseln
  Genre(s):
    Nature
--------------------
ID: 238879507
Title: Spitzbergen - Leben in Europas Kühlschrank
  Genre(s):
    Nature
--------------------
ID: 238879508
Title: Zimtstern und Halbmond
  Genre(s):
    Romance & Love
    Travel
--------------------

[TERWI]

Wow, so viel Code ! Danke euch allen. Aber wie immer das ABER:

@Delphi.Narium
So was in der Art hab ich hier schon für die Vorgänger-Datenversion.
Das wollte ich eigentlich etwas einfacher und übersichtlicher haben.

@jobo
Hm, auch noch SQL/Datenbank mit ins Boot ist eigentlich weit am Ziel vorbei...
Und ja: JSON (einfach) per Hand zu zerlegen ist die Intention. Siehe weiter unten.

@TiGü
Yepp, das funzt ! Allerdings müsste ich da sicher erst mal einen extended Durchblickerkurs machen, um zu verstehen wie das funktioniert und wie man das dann ggf. noch erweitert/anpasst.
Sehe ich das richtig, das die auserwählten Sender statisch im TChannelContainer vorgegeben sind ?
Falls ja: Das sollte vom User änderbar sein (hier mit Senderlisten-Editor)

Ich hab gesten Nacht noch rumgebastelt und dabei ist folgendes herausgekommen

Delphi-Quellcode:

// https://www.generacodice.com/en/articolo/4308375/how-to-parse-nested-json-object-in-delphi-xe2
procedure TForm1.ParseJson(data : string);
var
  JsonObj   : TJSONObject;
  JsonArray : TJSONArray;
  JsonValue : TJSonValue;
  chl       : TJSonValue;
  JsonPair  : TJSONPair;
  i, ii, n  : integer;
  LItem     : TJSONValue;
begin
  JsonObj    := TJSONObject.ParseJSONValue(TEncoding.ASCII.GetBytes(data),0) as TJSONObject;
  try
    JsonValue := JsonObj.Get('channels').JsonValue;
    for i := 0 to TJSONArray(JsonValue).Size - 1 do
    begin
      chl := TJSONArray(JsonValue).Get(i);
      JsonPair := TJSONPair(chl);
      // Listet den Sender-Namen
      Memo.Lines.Add(Format('Channel: %s',[JsonPair.JsonString.Value]));
      n := 1;
      for LItem in TJSONArray(JsonPair.JsonValue) do
      begin
        // Listet entsprechend Anzahl der Programme je Sender
        // .... den 'Inhalt' zwischen [ und ]
        Memo.Lines.Add('- Programm: ' + inttostr(n));
        inc(n);
        // ... wie bekomme ich  hier Zugriff auf die ProgrammDaten ?
        // also den 'Inhalt' zwischen { und }

      end;
    end;
  finally
     JsonObj.Free;
  end;
end;

Das ist mit Bordmitteln kurz, einfach, simpel und funzt so wie ich mir das denke.
... fehlt nur noch die "Kleinigkeit" siehe Text. Da fehlt mir noch das Verständnis bei JSON.
Vielleicht kann da jemand aushelfen und den letzen Denkanstoß geben ?!

[TERWI]

HA - ich habs raus !

Delphi-Quellcode:

// https://www.generacodice.com/en/articolo/4308375/how-to-parse-nested-json-object-in-delphi-xe2
procedure TForm1.ParseJson(data : string);
var
  JsonObj   : TJSONObject;
  JsonValue : TJSonValue;
  chl       : TJSonValue;
  dat       : TJSonValue;
  JsonPair  : TJSONPair;
  DataPair  : TJSONPair;
  i, ii, n  : integer;
  LItem     : TJSONValue;
begin
  Memo.Lines.BeginUpdate;
  JsonObj    := TJSONObject.ParseJSONValue(TEncoding.ASCII.GetBytes(data),0) as TJSONObject;
  try
    JsonValue := JsonObj.Get('channels').JsonValue;
    for i :=0 to TJSONArray(JsonValue).Size - 1 do
    begin
      chl := TJSONArray(JsonValue).Get(i);
      JsonPair := TJSONPair(chl);
      Memo.Lines.Add(Format('Channel: %s',[JsonPair.JsonString.Value]));
      n := 1;
      for LItem in TJSONArray(JsonPair.JsonValue) do
      begin
        Memo.Lines.Add('--  Programm: ' + inttostr(n));
        inc(n);
        for ii := 0 to TJSONArray(LItem).Size - 1 do
        begin
          dat := TJSONArray(LItem).Get(ii);
          DataPair := TJSONPair(dat);
          Memo.Lines.Add(Format('    ---- %s : %s',[DataPair.JsonString.Value, DataPair.JsonValue.Value]));
        end;
      end;
    end;
  finally
     JsonObj.Free;
  end;
  Memo.Lines.EndUpdate;
end;

Das war zwar mit Vollgas Versuch und Irrtum, aber lüppt.

[jobo]

Zitat von TERWI:

Hm, auch noch SQL/Datenbank mit ins Boot ist eigentlich weit am Ziel vorbei...
Und ja: JSON (einfach) per Hand zu zerlegen ist die Intention. Siehe weiter unten.

Naja, es sind halt Daten, die Du bearbeitest, durchsuchst, auf den Kopf stellst.
Und es ist wirklich einfach. Wenn man keine Umbenennung haben will, reichen ca 3 Zeilen SQL. Zugegeben, auf einer Apple Watch läuft es nicht.

Mir war eigentlich auch wichtig zu zeigen, dass man da nicht Buchstabe für Buchstabe dran geht. (Auch ohne DB)
Aber man kann es bestimmt auch in SQLite machen, das hat auch ganz gute JSON Funktionen und kleineren Fußabdruck.

[Uwe Raabe]

Zitat von TiGü:

Ausgehend von Uwes Konsolenprogramm und den richtigen Daten aus #9 aus dem Archiv schnell was zusammengezimmert.

Meiner Meinung nach scheidet der Ansatz wegen der Verwendung der Sendernamen als Schlüssel eigentlich aus. Man könnte vermutlich einen Interceptor schreiben, der das sinnvoll auflöst, aber das wäre zu viel Aufwand.

[TiGü]

Zitat von Uwe Raabe:

Zitat von TiGü:

Ausgehend von Uwes Konsolenprogramm und den richtigen Daten aus #9 aus dem Archiv schnell was zusammengezimmert.

Meiner Meinung nach scheidet der Ansatz wegen der Verwendung der Sendernamen als Schlüssel eigentlich aus. Man könnte vermutlich einen Interceptor schreiben, der das sinnvoll auflöst, aber das wäre zu viel Aufwand.

Ja, daher hier nochmal die Version zu Fuß (sollte dadurch auch schneller sein?):

Delphi-Quellcode:

procedure ParseJsonTERWI;
var
    JsonRoot, JsonChannels, JsonEPGInfo: TJSONObject;
    JsonEPGInfos, JsonEPGDetailInfoArray: TJSONArray;
    JsonValue, JsonValue2, JsonSingleChannel: TJSonValue;
    JsonPair, JsonPair2: TJSONPair;
    I, N, J: integer;
    FileContent, ProgramName: string;
begin
    FileContent := TFile.ReadAllText('EPG_GUIDE.json');
    JsonRoot := TJSONObject.ParseJSONValue(TEncoding.ASCII.GetBytes(FileContent), 0) as TJSONObject;
    try
        JsonValue := JsonRoot.Get('channels').JsonValue;
        if JsonValue is TJSONObject then
        begin
            JsonChannels := TJSONObject(JsonValue);
            Writeln('Es gibt soviele Kanäle: ', JsonChannels.Count);
            Writeln('Enter-Taste drücken...');
            Readln;

            Writeln(sLineBreak + 'Auflistung der Kanäle...');
            N := 1;
            for JsonPair in JsonChannels do
            begin
                ProgramName := JsonPair.JsonString.Value;
                Writeln(N.ToString + '. ', ProgramName);
                Inc(N);
            end;

            Writeln(sLineBreak + 'EPG-Informationen der ersten 3 Sender...');
            Writeln('Enter-Taste drücken...');
            Readln;

            N := 1;
            for JsonPair in JsonChannels do
            begin
                if JsonPair.JsonValue is TJSONArray then
                begin
                    JsonEPGInfos := TJSONArray(JsonPair.JsonValue);
                    Writeln(sLineBreak + N.ToString + '. ', ProgramName + ' hat soviele EPG-Informationen: ', JsonEPGInfos.Count);
                    for I := 0 to JsonEPGInfos.Count - 1 do
                    begin
                        JsonValue2 := JsonEPGInfos.Items[I];
                        if JsonValue2 is TJSONObject then
                        begin
                            JsonEPGInfo := TJsonObject(JsonValue2);
                            Writeln('...die EPG-Information hat soviele Einträge: ', JsonEPGInfo.Count);
                            for JsonPair2 in JsonEPGInfo do
                            begin
                                // das hier wäre die Stelle wo du aus JsonPair2.JsonValue dir die nötigen Informationen
                                // für deine Klassenstruktur/Liste/EPG-Guide zusammenpuzzeln musst.
                                Writeln('......', JsonPair2.JsonString.Value, ':  ', JsonPair2.JsonValue.ToString);

                                // Wenn JsonPair2.JsonValue ein Array ist (z.B. Genres), dann hier nochmal genauer reingucken:
                                if JsonPair2.JsonValue is TJSONArray then
                                begin
                                    JsonEPGDetailInfoArray := TJSONArray(JsonPair2.JsonValue);

                                    for J := 0 to JsonEPGDetailInfoArray.Count - 1 do
                                    begin
                                        Writeln('.........', JsonEPGDetailInfoArray.Items[J].Value);
                                    end;
                                end;
                            end;
                        end;
                    end;
                end;

                Inc(N);
                if N = 3 then
                begin
                    Writeln(sLineBreak + 'Damit es nicht zuviel wird, brechen wir hier nach 3 Sendern ab!');
                    Break;
                end;
            end;

            // Beispiel für einzelnen Sender -> hier dann wie oben auswerten!
            JsonSingleChannel := JsonChannels.GetValue('ard');
            if JsonSingleChannel is TJSONArray then
            begin
                JsonEPGInfos := TJSONArray(JsonSingleChannel);
                // usw. usf.
            end;
        end;

        Writeln('Enter-Taste drücken...');
        Readln;
    finally
        JsonRoot.Free;
    end;
end;

[TERWI]

@TiGü
...irgendwie ist das doch das gleiche wie in meinem Post #27, nur etwas anders mit mehr Info.
Was ist schneller als was ? Uwe's Version oder die von jobo oder TiGü... 'per Json-Hand filetiert' ...
Geschwindigkeit ist bei mir bei den eher kleinen Datenmengen (< 1MByte) nicht so die Wichtgkeit.
Ich lege Wert drauf, dass ich das verstanden habe was ich/andere da geproggt haben und für mich auch später bei Bedarf modifizieren kann.

[Uwe Raabe]

Ich hatte etwas Muße das nochmal detaillierter zu betrachten. Herausgekommen ist dabei eine hybride Lösung:

Delphi-Quellcode:

unit TestJSON1Unit1;

interface

uses
  System.SysUtils, System.Classes, System.Generics.Collections,
  REST.JSON.Types, REST.Json, System.JSON;

type
  TEPGInfo = class
  private
    FId: Integer;
    [JSONName('t')]
    FTitle: string;
    [JSONName('et')]
    FEpisode_Title: string;
    [JSONName('g')]
    FGenre: TArray<string>;
  public
    property Id: Integer read FId;
    property Title: string read FTitle;
    property Episode_Title: string read FEpisode_Title;
    property Genre: TArray<string> read FGenre;
  end;

type
  TChannel = class(TObjectList<TEPGInfo>)
  private
    FName: string;
  public
    property Name: string read FName write FName;
  end;
  TChannels = class(TObjectDictionary<string, TChannel>);

procedure LoadChannels(const AJson: string; Target: TChannels; const AChannels: TArray<string> = nil);

implementation

uses
  System.StrUtils;

procedure LoadChannels(const AJson: string; Target: TChannels; const AChannels: TArray<string> = nil);
var
  channel: TChannel;
  channelName: string;
  item: TJSONValue;
  jsonObj: TJSONObject;
  jsonValue: TJSONValue;
  pair: TJSONPair;
begin
  jsonValue := TJSONObject.ParseJSONValue(AJson);
  try
    jsonObj := (jsonValue as TJSONObject).Values['channels'] as TJSONObject;
    for pair in jsonObj do begin
      channelName := pair.JsonString.Value;
      if (Length(AChannels) > 0) and not MatchText(channelName, AChannels) then Continue;
      channel := TChannel.Create;
      channel.Name := channelName;
      for item in (pair.JsonValue as TJSONArray) do
        channel.Add(TJson.JsonToObject<TEPGInfo>(item as TJSONObject));
      Target.Add(channel.Name, channel);
    end;
  finally
    jsonValue.Free;
  end;
end;

end.

Aufgerufen wird das dann so:

Delphi-Quellcode:

program TestJSON1;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  System.IOUtils,
  System.Generics.Collections,
  TestJSON1Unit1 in 'TestJSON1Unit1.pas';

procedure ListChannels(Channels: TChannels);
{ Sender auflisten }
var
  arr: TArray<string>;
  S: string;
begin
  arr := Channels.Keys.ToArray;
  TArray.Sort<string>(arr);
  for S in arr do
    Writeln(S);
end;

procedure ListProgram(Channels: TChannels; const AName: string);
{ Programm auflisten }
var
  channel: TChannel;
  info: TEPGInfo;
begin
  channel := Channels[AName];
  if channel <> nil then begin
    Writeln(channel.Name);
    for info in channel do
      Writeln(Format('%d: %s - %s (%s)', [info.Id, info.title, info.Episode_Title, string.Join(',', info.Genre)]));
  end;
end;

procedure ParseJson();
var
  arr: TArray<string>;
  channel: TChannel;
  channels: TChannels;
  FileContent: string;
  info: TEPGInfo;
  S: string;
begin
  FileContent := TFile.ReadAllText('c:\Users\Uwe\Downloads\EPG_GUIDE\EPG_GUIDE.json');
  channels := TChannels.Create;
  try
    LoadChannels(FileContent, channels, ['ard', 'zdf']);
    ListChannels(channels);
    ListProgram(channels, 'ard');
    ListProgram(channels, 'zdf');
  finally
    channels.Free;
  end;
end;

begin
  try
    ParseJson;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Write('press enter...');
  Readln;
end.

Sollten weitere EPG-Felder benötigt werden, reicht es diese in der Klasse TEPGInfo entsprechend zu ergänzen.

[TERWI]

Danke dir, Uwe. Das werde ich zeitnah mal testen.

Da fehlen logo noch etliche Daten in TEPGInfo.
Die Klasse erweitern ist sicher nicht das Problem, aber ....

Die Daten (erweiterte EPG-Texte/Beschreibungen) kommen aus einer 2ten Datei separat je Sender zu laden.
Funzt das im Prinzip genauso ?
Dito die Logo's zum Sender und 'Live-Pics" vom Programm, welche sich 'im Zeitraffer' (alle 15 Sekunden ?!) ändern und ggf. nachzuladen wäre (nur prinzipiell...)