Streaming JSON/pl

From Lazarus wiki

Deutsch (de) English (en) polski (pl) русский (ru)

JSON (JavaScript Object Notation) to tekstowy, znormalizowany format danych. Jak sama nazwa wskazuje, dokumenty JSON są poprawnym kodem JavaScript i mogą być bezpośrednio konwertowane na obiekty JavaScript. JSON może jednak służyć do wymiany danych niezależnie od używanego języka programowania.

W tym samouczku wyjaśniono, jak ładować dane JSON do programu Free Pascal i jak je w nim przetwarzać. Wyjaśnia także, jak konwertować dane z programu do JSON (np. Aby wysłać je do przeglądarki internetowej).

Ogólne wymagania

Ładowanie i przechowywanie (przesyłanie strumieniowe) obiektów odbywa się za pomocą modułu fpjsonrtti. Ale ma to sens, gdy użyty jest również moduł Classes (szczegóły poniżej).

Instrukcja użycia powinna zatem zawierać przynajmniej te dwa moduły:

uses Classes, fpjsonrtti;

Obecnie (maj 2014) istnieją pewne różnice między systemem przesyłania strumieniowego Free Pascala a JSON:

  • JSON to format danych, w którym rozróżniana jest wielkość liter. Wynika z tego, że właściwości obiektów Free Pascal muszą być zapisane w tym samym miejscu, co właściwości JSON.
  • Za pomocą DefineProperties nie można zdefiniować żadnych właściwości. Nie można zapisać odwołań do metod (procedur obsługi zdarzeń).2
  • TCollection i TStrings mogą być stosowane jako zamienniki tablic.

Programy demonstracyjne wraz z kodem źródłowym kompilatora Free Pascal znajdują się w katalogu packages/fcl-json/examples.

Taka jak poniżej struktura JSON, jest używana w dalszych przykładach:

{
  "id"     : 123,                                                // liczba całkowita (integer)
  "obj"    : { "name": "Witaj Świecie!" },                       // jakiś obiekt
  "coll"   : [ { "name": "Obiekt 1" }, { "name": "Obiekt 2" } ], // dwa obiekty w TCollection
  "strings": [ "Witaj 1", "Witaj 2" ]                            // ciągi znaków
}

Można ją zdefiniować w programie Free Pascal jako wartość stałą w następujący sposób:

const JSON_TESTDATA =
'{'+LineEnding+
'  "id": 123,'+LineEnding+
'  "obj": { "name": "Witaj Świecie!" },'+LineEnding+
'  "coll": [ { "name": "Obiekt 1" }, { "name": "Obiekt 2" } ],'+LineEnding+
'  "strings": [ "Witaj 1", "Witaj 2" ]'+LineEnding+
'}';

Struktura danych

Podstawową klasą danych jest TPersistent z modułu Classes, ponieważ dla niej i wszystkich podklas tworzona jest informacja o typie środowiska wykonawczego (RTTI). Są one niezbędne do przesyłania strumieniowego. Ponieważ fpjsonrtti nie integruje się z systemem przesyłania strumieniowego, można również użyć dowolnej innej klasy przetłumaczonej za pomocą przełącznika kompilatora {$M+}.

Wszystkie właściwości do odczytu muszą być zadeklarowane w klasie jako property w sekcji published. Z reguły można używać odczytu i zapisu w celu odniesienia bezpośrednio do pola danych (zmiennej). Jeśli chcesz, możesz oczywiście użyć metod get i set.

Poniższa definicja klasy wynika ze struktury JSON:

type
  TNameObject = class(TCollectionItem) // klasa dla właściwości 'obj' typu TCollection 
  private
    fName: String;
  published
    property name: String read fName write fName;
  end;  

  TBaseObject = class(TPersistent)  // klasa dla całej struktury JSON
  private
    fid: Integer;
    fObj: TNameObject;
    fColl: TCollection;
    fStrings: TStrings;
  public
    constructor Create;
    destructor Destroy; override;
  published                         // wszystkie właściwości muszą mieć prawa dostępu published
    property id: Integer read fid write fid;
    property obj: TNameObject read fObj write fObj;
    property coll: TCollection read fColl;
    property strings: TStrings read fStrings;
  end;

Klasa TNameObject została odziedziczona z TCollectionItem. Oznacza to, że można ją używać zarówno dla właściwości obj, jak i dla coll. Jeśli nie jest to pożądane, należy zdefiniować tutaj dwie różne klasy.

TCollection i TStrings muszą zostać utworzone w konstruktorze klasy TBaseObject i zwolnione w destruktorze.

constructor TBaseObject.Create;
begin
  // Utwórz kolekcję i listę ciągów
  fColl    := TCollection.Create(TNameObject);
  fStrings := TStringList.Create;
  fObj     := TNameObject.Create(nil);
end;

destructor TBaseObject.Destroy;
begin
  // Zwolnij kolekcję i listę ciągów
  fColl.Free;
  fStrings.Free;
  fObj.Free;
  inherited Destroy;
end;

Jeśli nie chcesz mieć więcej funkcji w klasach danych, ich definicja jest teraz kompletna.

Załaduj JSON

Za pomocą metody Procedure JSONToObject(Const JSON : TJSONStringType; AObject : TObject); w klasie TJSONDeStreamer można przypisać dane JSON bezpośrednio do istniejącego obiektu. Przed wywołaniem metody należy utworzyć TJSONDeStreamer i obiekt docelowy.

Poniższa metoda ładuje dane ze struktury JSON JSON_TESTDATA w obiekcie o, a następnie wypisuje bieżące wartości właściwości do konsoli.

procedure DeStreamTest;
var
  DeStreamer: TJSONDeStreamer;
  o: TBaseObject;
  no: TNameObject;
  s: String;
begin
  WriteLn('DeStream test');
  WriteLn('======================================');

  // Utwórz obiekt DeStreamer i obiekt docelowy
  DeStreamer := TJSONDeStreamer.Create(nil);
  o := TBaseObject.Create;
  try
    // Załaduj dane JSON do obiektu o
    DeStreamer.JSONToObject(JSON_TESTDATA, o);
    // wypisz ID
    WriteLn(o.id);
    // wypisz nazwę obiektu
    WriteLn(o.obj.name); 
    // wypisz nazwy wszystkich obiektów
    for TCollectionItem(no) in o.coll do
      Writeln(no.name);
    // wypisz wszystkie ciągi
    for s in o.strings do
      WriteLn(s);

  // Czyszczenie
  finally
    o.Destroy;
    DeStreamer.Destroy;
  end;
end;

Zapisywanie JSON

Klasa TJSONStreamer służy do konwersji obiektu na tekstowy JSON. Tutaj używana jest metoda Function ObjectToJSONString(AObject : TObject) : TJSONStringType;.

W poniższej procedurze tworzony jest obiekt, wypełniany danymi testowymi, a następnie konwertowany na JSON. Tekst JSON jest wyprowadzany na konsolę. Kolejność, w jakiej właściwości są wyprowadzane, nie może zostać określona.

procedure StreamTest;
var
  Streamer: TJSONStreamer;
  o: TBaseObject;
  JSONString: String;
begin
  WriteLn('Stream test');
  WriteLn('======================================');

  Streamer := TJSONStreamer.Create(nil);
  o := TBaseObject.Create;
  try
    // Skonfiguruj dane
    o.id := 123;
    o.obj.name := 'Witaj Świecie!';
    TNameObject(o.coll.Add).name := 'Obiekt 1';
    TNameObject(o.coll.Add).name := 'Obiekt 2';
    o.strings.Add('Witaj 1');
    o.strings.Add('Witaj 2');

    Streamer.Options := Streamer.Options + [jsoTStringsAsArray]; // Zapisz ciągi jako tablicę JSON
    // konwersja do JSON i na wyjście konsoli
    JSONString := Streamer.ObjectToJSONString(o);
    WriteLn(JSONString);

  // Czyszczenie
  finally
    o.Destroy;
    Streamer.Destroy;
  end;
end;

Wnioski

Dzięki przedstawionej tu wiedzy, proste i złożone struktury danych JSON można załadować do programów Free Pascal. Jeśli konieczne będzie jakiekolwiek wstępne lub końcowe przetwarzanie danych JSON, dane tekstowe można najpierw załadować z modułu jsonparser do struktury danych JSON przy użyciu klasy TJSONParser, a następnie odpowiednio manipulować za pomocą modułu fpJSON.

Za pomocą właściwości Options klasy TJSONStreamer można kontrolować, w jaki sposób dane wyjściowe mapują własne struktury danych w JSON.

Zobacz także

Uwagi i referencje