Streaming JSON/pl
│
Deutsch (de) │
English (en) │
polski (pl) │
русский (ru) │
中文（中国大陆） (zh_CN) │
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.
