Streaming JSON/pl: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		[[JSON/pl\|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.
2	2
3	3		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).
4	4
5	5		## Ogólne wymagania
6	6
7	7		Ł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).
8	8
9	9		Instrukcja użycia powinna zatem zawierać przynajmniej te dwa moduły:
10	10
11	11		``` pascal
12	12		uses Classes, fpjsonrtti;
13	13		```
14	14
15	15		Obecnie (maj 2014) istnieją pewne różnice między systemem przesyłania strumieniowego Free Pascala a JSON:
16	16
17	17		- 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.
18	18		- 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
19	19		- [[TCollection/pl\|TCollection]] i [[TStrings]] mogą być stosowane jako zamienniki tablic.
20	20
21	21		Programy demonstracyjne wraz z kodem źródłowym kompilatora Free Pascal znajdują się w katalogu `packages/fcl-json/examples`.
22	22
23	23		Taka jak poniżej struktura JSON, jest używana w dalszych przykładach:
24	24
25	25		``` JavaScript
26	26		{
27	27		"id" : 123, // liczba całkowita (integer)
28	28		"obj" : { "name": "Witaj Świecie!" }, // jakiś obiekt
29	29		"coll" : [ { "name": "Obiekt 1" }, { "name": "Obiekt 2" } ], // dwa obiekty w TCollection
30	30		"strings": [ "Witaj 1", "Witaj 2" ] // ciągi znaków
31	31		}
32	32		```
33	33
34	34		Można ją zdefiniować w programie Free Pascal jako wartość stałą w następujący sposób:
35	35
36	36		``` pascal
37	37		const JSON_TESTDATA =
38	38		'{'+LineEnding+
39	39		' "id": 123,'+LineEnding+
40	40		' "obj": { "name": "Witaj Świecie!" },'+LineEnding+
41	41		' "coll": [ { "name": "Obiekt 1" }, { "name": "Obiekt 2" } ],'+LineEnding+
42	42		' "strings": [ "Witaj 1", "Witaj 2" ]'+LineEnding+
43	43		'}';
44	44		```
45	45
46	46		## Struktura danych
47	47
48	48		Podstawową klasą danych jest [[TPersistent]] z modułu Classes, ponieważ dla niej i wszystkich podklas tworzona jest [[Runtime Type Information (RTTI)\|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+}.
49	49
50	50		Wszystkie właściwości do odczytu muszą być zadeklarowane w klasie jako [[Property\|property]] w sekcji [[Published\|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.
51	51
52	52		Poniższa definicja klasy wynika ze struktury JSON:
53	53
54	54		``` pascal
55	55		type
56	56		TNameObject = class(TCollectionItem) // klasa dla właściwości 'obj' typu TCollection
57	57		private
58	58		fName: String;
59	59		published
60	60		property name: String read fName write fName;
61	61		end;
62	62
63	63		TBaseObject = class(TPersistent) // klasa dla całej struktury JSON
64	64		private
65	65		fid: Integer;
66	66		fObj: TNameObject;
67	67		fColl: TCollection;
68	68		fStrings: TStrings;
69	69		public
70	70		constructor Create;
71	71		destructor Destroy; override;
72	72		published // wszystkie właściwości muszą mieć prawa dostępu published
73	73		property id: Integer read fid write fid;
74	74		property obj: TNameObject read fObj write fObj;
75	75		property coll: TCollection read fColl;
76	76		property strings: TStrings read fStrings;
77	77		end;
78	78		```
79	79
80	80		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.
81	81
82	82		TCollection i TStrings muszą zostać utworzone w konstruktorze klasy TBaseObject i zwolnione w destruktorze.
83	83
84	84		``` pascal
85	85		constructor TBaseObject.Create;
86	86		begin
87	87		// Utwórz kolekcję i listę ciągów
88	88		fColl := TCollection.Create(TNameObject);
89	89		fStrings := TStringList.Create;
90	90		fObj := TNameObject.Create(nil);
91	91		end;
92	92
93	93		destructor TBaseObject.Destroy;
94	94		begin
95	95		// Zwolnij kolekcję i listę ciągów
96	96		fColl.Free;
97	97		fStrings.Free;
98	98		fObj.Free;
99	99		inherited Destroy;
100	100		end;
101	101		```
102	102
103	103		Jeśli nie chcesz mieć więcej funkcji w klasach danych, ich definicja jest teraz kompletna.
104	104
105	105		## Załaduj JSON
106	106
107	107		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.
108	108
109	109		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.
110	110
111	111		``` pascal
112	112		procedure DeStreamTest;
113	113		var
114	114		DeStreamer: TJSONDeStreamer;
115	115		o: TBaseObject;
116	116		no: TNameObject;
117	117		s: String;
118	118		begin
119	119		WriteLn('DeStream test');
120	120		WriteLn('======================================');
121	121
122	122		// Utwórz obiekt DeStreamer i obiekt docelowy
123	123		DeStreamer := TJSONDeStreamer.Create(nil);
124	124		o := TBaseObject.Create;
125	125		try
126	126		// Załaduj dane JSON do obiektu o
127	127		DeStreamer.JSONToObject(JSON_TESTDATA, o);
128	128		// wypisz ID
129	129		WriteLn(o.id);
130	130		// wypisz nazwę obiektu
131	131		WriteLn(o.obj.name);
132	132		// wypisz nazwy wszystkich obiektów
133	133		for TCollectionItem(no) in o.coll do
134	134		Writeln(no.name);
135	135		// wypisz wszystkie ciągi
136	136		for s in o.strings do
137	137		WriteLn(s);
138	138
139	139		// Czyszczenie
140	140		finally
141	141		o.Destroy;
142	142		DeStreamer.Destroy;
143	143		end;
144	144		end;
145	145		```
146	146
147	147		## Zapisywanie JSON
148	148
149	149		Klasa [[TJSONStreamer]] służy do konwersji obiektu na tekstowy JSON. Tutaj używana jest metoda `Function ObjectToJSONString(AObject : TObject) : TJSONStringType;`.
150	150
151	151		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.
152	152
153	153		``` pascal
154	154		procedure StreamTest;
155	155		var
156	156		Streamer: TJSONStreamer;
157	157		o: TBaseObject;
158	158		JSONString: String;
159	159		begin
160	160		WriteLn('Stream test');
161	161		WriteLn('======================================');
162	162
163	163		Streamer := TJSONStreamer.Create(nil);
164	164		o := TBaseObject.Create;
165	165		try
166	166		// Skonfiguruj dane
167	167		o.id := 123;
168	168		o.obj.name := 'Witaj Świecie!';
169	169		TNameObject(o.coll.Add).name := 'Obiekt 1';
170	170		TNameObject(o.coll.Add).name := 'Obiekt 2';
171	171		o.strings.Add('Witaj 1');
172	172		o.strings.Add('Witaj 2');
173	173
174	174		Streamer.Options := Streamer.Options + [jsoTStringsAsArray]; // Zapisz ciągi jako tablicę JSON
175	175		// konwersja do JSON i na wyjście konsoli
176	176		JSONString := Streamer.ObjectToJSONString(o);
177	177		WriteLn(JSONString);
178	178
179	179		// Czyszczenie
180	180		finally
181	181		o.Destroy;
182	182		Streamer.Destroy;
183	183		end;
184	184		end;
185	185		```
186	186
187	187		## Wnioski
188	188
189	189		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]].
190	190
191	191		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.
192	192
193	193		## Zobacz także
194	194
195	195		- [[JSON/pl\|JSON]]
196	196		- [[fcl-json/pl\|fcl-json]]
197	197		- [[Streaming components/pl\|Komponenty strumieniowe]]
198	198
199	199		## Uwagi i referencje
200	200
201		-	~~1. <div id="ref1">~~
202		-
203		-	~~<http://lists.freepascal.org/fpc-pascal/2013-January/036254.html>~~
204		-
205		-	~~</div>~~
	201	+	1. <http://lists.freepascal.org/fpc-pascal/2013-January/036254.html>
206	202
207	203		2. \<div id="ref2\>http://lists.lazarus.freepascal.org/pipermail/lazarus/2011-January/058878.html
208		-	~~</div>~~
209	204
210	205		---
211	206		From the Free Pascal wiki, page "Streaming JSON/pl", as it stood on 2023-01-31 after a change by Slawek, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history