Json اسڪيم: ڇو ۽ ڪير ان جي ضرورت آهي

هيلو ، گهمندڙ. اڄ مان توهان کي هڪ ننڍڙي جادو جي باري ۾ ٻڌائڻ چاهيان ٿو. توھان شايد اڳ ۾ ئي ٻڌو آھي json بابت. هيءَ اهڙي آفاقي ٻولي آهي: اها مشين ذريعي سمجهي ويندي آهي ۽ آسانيءَ سان انسان پڙهي سگهي ٿي. هتي هڪ json پيغام جو هڪ عام مثال آهي:

{
   "помещение":{
      "название":"избушка",
      "разумна":true
   },
   "основание":{
      "тип":"курьи ноги",
      "количество":2
   },
   "проживающие":[
      {
         "Name":"Баба Яга",
         "профиль":"ведьма"
      }
   ],
   "местоположение":{
      "address":"граница леса"
   }
}

اهو آسان آهي گفتگو ڪرڻ لاء انهي وانگر، ڇا اهو ناهي؟ جيڪڏهن توهان کي خبر ناهي ته json اڳ ڇا هو، هاڻي توهان ڪريو ٿا. جاوا ڪوڊ ۾ هي ڪيئن استعمال ڪجي؟ Json هڪ عالمگير شڪل بڻجي چڪو آهي. اهو JavaScript Object Notation لاءِ بيٺو آهي، پر گهڻي عرصي کان جاوا اسڪرپٽ کان اڳتي نڪري چڪو آهي ۽ تقريبن هر هنڌ استعمال ٿيندو آهي. جاوا وٽ ڪيتريون ئي لائبريريون آهن جيڪي json سان ڪم ڪرڻ آسان بڻائين ٿيون. هتي سڀ کان وڌيڪ مشهور آهن:

• gson
• جڪسن

مان ٻيو استعمال ڪندس. انھن جا 2 ورجن آھن : codehaus ۽ fasterxml ، مون انھن ۾ ڪو به فرق محسوس نه ڪيو، تنھنڪري توھان ھتي ڪو به استعمال ڪري سگھو ٿا. هتي ڪوڊ جو هڪ ٽڪرو آهي:

ObjectMapper mapper = new ObjectMapper();
return mapper.readValue("сюда json", "сюда класс");

json کي هڪ اعتراض ۾ ترجمو ڪرڻ ۾ مدد ڪندو. ۽ اسان سڀ کان اهم شيء تي پهچي رهيا آهيون. هن json لاءِ ڪلاس لکڻ. توھان ھي دستي طور ڪري سگھو ٿا، ھڪڙي جوڙجڪ ٺاھيو ڪجھ ھن طرح:

-----------------------------------com.fairytale.Base.java-----------------------------------

package com.fairytale;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;


@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
"type",
"quantity"
})
public class Base {

@JsonProperty("type")
public String type = "";
@JsonProperty("quantity")
public int quantity = 0;

}
-----------------------------------com.fairytale.Hut.java-----------------------------------

package com.fairytale;

import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;


@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
"room",
"base",
"residents",
"location"
})
public class Hut {

@JsonProperty("room")
public Room room;
@JsonProperty("base")
public Base base;
@JsonProperty("residents")
public List<Resident> residents = new ArrayList<Resident>();
@JsonProperty("location")
public Location location;

}
-----------------------------------com.fairytale.Location.java-----------------------------------

package com.fairytale;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;


@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
"address"
})
public class Location {

@JsonProperty("address")
public String address = "";

}
-----------------------------------com.fairytale.Resident.java-----------------------------------

package com.fairytale;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;


@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
"name",
"profile"
})
public class Resident {

@JsonProperty("name")
public String name = "";
@JsonProperty("profile")
public String profile = "";

}
-----------------------------------com.fairytale.Room.java-----------------------------------

package com.fairytale;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
"name",
"reasonable"
})
public class Room {

@JsonProperty("name")
public String name = "";
@JsonProperty("reasonable")
public boolean reasonable = false;

}

مون خاص طور تي گيٽر، سيٽٽر، تعمير ڪندڙ ۽ ٻيون پوجو خاصيتون ختم ڪيون، ٻي صورت ۾ توهان ضايع ڪرڻ کان تنگ ٿي ويندا =) هاڻي هتي ڏسو:

{
  "definitions": {},
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "http://example.com/root.json",
  "type": "object",
  "title": "The Root Schema",
  "required": [
    "room",
    "base",
    "residents",
    "location"
  ],
  "properties": {
    "room": {
      "$id": "#/properties/room",
      "type": "object",
      "title": "The Room Schema",
      "required": [
        "name",
        "reasonable"
      ],
      "properties": {
        "name": {
          "$id": "#/properties/room/properties/name",
          "type": "string",
          "title": "The Name Schema",
          "default": "",
          "examples": [
            "избушка"
          ],
          "pattern": "^(.*)$"
        },
        "reasonable": {
          "$id": "#/properties/room/properties/reasonable",
          "type": "boolean",
          "title": "The Reasonable Schema",
          "default": false,
          "examples": [
            true
          ]
        }
      },
	"additionalProperties": false
    },
    "base": {
      "$id": "#/properties/base",
      "type": "object",
      "title": "The Base Schema",
      "required": [
        "type",
        "quantity"
      ],
      "properties": {
        "type": {
          "$id": "#/properties/base/properties/type",
          "type": "string",
          "title": "The Type Schema",
          "default": "",
          "examples": [
            "курьи ноги"
          ],
          "pattern": "^(.*)$"
        },
        "quantity": {
          "$id": "#/properties/base/properties/quantity",
          "type": "integer",
          "title": "The Quantity Schema",
          "default": 0,
          "examples": [
            2
          ]
        }
      },
	"additionalProperties": false
    },
    "residents": {
      "$id": "#/properties/residents",
      "type": "array",
      "title": "The Residents Schema",
      "items": {
        "$id": "#/properties/residents/items",
        "type": "object",
        "title": "The Items Schema",
        "required": [
          "name",
          "profile"
        ],
        "properties": {
          "name": {
            "$id": "#/properties/residents/items/properties/name",
            "type": "string",
            "title": "The Name Schema",
            "default": "",
            "examples": [
              "Баба Яга"
            ],
            "pattern": "^(.*)$"
          },
          "profile": {
            "$id": "#/properties/residents/items/properties/profile",
            "type": "string",
            "title": "The Profile Schema",
            "default": "",
            "examples": [
              "ведьма"
            ],
            "pattern": "^(.*)$"
          }
        },
	    "additionalProperties": false
      }
    },
    "location": {
      "$id": "#/properties/location",
      "type": "object",
      "title": "The Location Schema",
      "required": [
        "address"
      ],
      "properties": {
        "address": {
          "$id": "#/properties/location/properties/address",
          "type": "string",
          "title": "The Address Schema",
          "default": "",
          "examples": [
            "граница леса"
          ],
          "pattern": "^(.*)$",
		  "additionalProperties": false
        }
      },
	"additionalProperties": false
    }
  },
	"additionalProperties": false
}

مٿي ڏنل ڍانچي جو هي json ڊراگرام آهي. هاڻي اهو وقت آهي وضاحت ڪرڻ جو توهان کي ان جي ضرورت ڇو آهي. اهو طبقن کي لکڻ ۽ انهن کي برقرار رکڻ جي ضرورت کي ختم ڪندو. اتي ھڪڙو سٺو منصوبو آھي jsonschema2pojo . اهو پروجيڪٽ ٺاهيندڙن (Maven، Gradle) لاءِ پلگ ان پيش ڪري ٿو جيڪي توهان جي تعمير وقت تي اهي ڪلاس لکندا. هتي منهنجي منصوبي مان هڪ مثال آهي:

<plugin>
    <groupId>org.jsonschema2pojo</groupId>
    <artifactId>jsonschema2pojo-maven-plugin</artifactId>
    <version>0.4.37</version>

    <executions>
        <execution>
            <id>jsonschema2opjo</id>
            <configuration>
                <sourceDirectory>${project.basedir}/src/main/resources/json-schema/</sourceDirectory>
                <targetPackage>tester.model</targetPackage>
                <outputDirectory>${project.basedir}/target/generated-sources/jsonschema/</outputDirectory>
                <useCommonsLang3>true</useCommonsLang3>
                <includeConstructors>true</includeConstructors>
                <generateBuilders>true</generateBuilders>
                <includeToString>true</includeToString>
                <usePrimitives>true</usePrimitives>
            </configuration>
            <goals>
                <goal>generate</goal>
            </goals>
            <phase>generate-sources</phase>
        </execution>
    </executions>
</plugin>

هي هن جي ترتيب آهي. سڀ کان وڌيڪ دلچسپ شيء هتي آهي:

<useCommonsLang3>true</useCommonsLang3>
<includeConstructors>true</includeConstructors>
<generateBuilders>true</generateBuilders>
<includeToString>true</includeToString>
<usePrimitives>true</usePrimitives>

هي هڪ هدايت آهي ته ڪلاس ڪيئن لکجي: useCommonsLang3 - CommonsLang3 لائبريري استعمال ڪريو includeConstructors - لکندو هڪ تعمير ڪندڙ generateBuilders - هڪ نمونو تعمير ڪندو includeToString - add toString usePrimitives - primitives استعمال ڪرڻ جي هدايت - هي گهر ۾ لکيل ڪوڊ کان ڪيئن بهتر آهي ؟

1. توهان هڪ قطار سان ڪلاس کي ترتيب ڏئي سگهو ٿا. مثال طور، توهان کي هر طبقي ۾ پوجو لافڪس شامل ڪرڻ جي ضرورت آهي. بس شامل ڪريو <classNameSuffix>Pojo</classNameSuffix> پروجيڪٽ کي گڏ ڪرڻ لاءِ - ۽ توهان مڪمل ڪيو. ٻي صورت ۾، اسان کي دستي طور تي هر طبقي جا نالا تبديل ڪرڻو پوندو.

   انهن مان گھڻا پيٽرول آھن، اھو انھن سڀني جي باري ۾ پڙھڻ جي قابل آھي دستاويز ۾

2. جيڪڏهن توهان جي پروجيڪٽ ۾ هڪ صارف آهي، ان کي جاوا ڪلاس جي بدران json اسڪيما ڏيڻ تمام آسان ٿيندو. جيئن مون اڳ ۾ چيو آهي، اسڪيمون آفاقي آهن ۽ صارف صرف پنهنجي ٻولي ۾ پوجو ٺاهيندو.

3. اهي تمام ننڍا آهن. مٿين مثال ۾ تمام گهڻي معلومات شامل آهي جيڪا هميشه ضروري ناهي، مثال طور، نمونن ۽ مثالن. پر جيڪڏھن توھان انھن کي جاوا ڪوڊ ڏانھن موٽايو، اھو پڻ تمام گھڻو وڌندو. ۽ ٽيمپليٽ ڪوڊ جي باري ۾ نه وساريو، جيڪو پلگ ان ۾ ڪجهه سيٽنگن ذريعي ڊراگرام ۾ اشارو ڪيو ويو آهي، پر توهان کي ان کي ڪوڊ ۾ پاڻ کي لکڻو پوندو. ۽ ها، مان لومبوڪ بابت ڄاڻان ٿو، اتي هڪ متبادل آهي.

4. پوجو ۾ ڪوبه منطق ناهي. جڏهن توهان جا ڪلاس خود لکيا ويندا آهن، ڪنهن کي آزمائي سگهجي ٿو ته هڪ طريقو شامل ڪرڻ لاء جيڪو انهن لاء آسان آهي. طريقو json اسڪيما ۾ شامل نه ٿو ڪري سگھجي، انهي سان گڏ ٺاهيل طبقي ۾.

اهو شايد سڀ ڪجهه آهي.

نتيجو:

مون اهو ٻڌائڻ جي ڪوشش ڪئي ته json اسڪيمون منصوبن جي وچ ۾ رابطي لاءِ تمام سٺي شڪل آهن. هڪ ڏينهن منهنجي ساڻس هڪ پروجيڪٽ تي ملاقات ٿي، ۽ هو منهنجي دل ۾ پئجي ويو. آئون انهن کي تقريبا هر جڳهه استعمال ڪريان ٿو. ها، اهو هميشه آسان ناهي، ڇاڪاڻ ته ذريعن کي ڏسڻ لاء، توهان کي منصوبي کي گڏ ڪرڻ جي ضرورت آهي. پر هي پوجو آهي، جنهن جو مطلب آهي ته اتي منطق نه ٿي سگهي، ۽ اتي سرڪٽ سان ڪو به نه هوندو. PS.. ڪڏهن ڪڏهن آئون خراب وضاحت ڪريان ٿو، تنهنڪري هتي هڪ سٺي رپورٽ سان هڪ وڊيو آهي: Kirill Merkushev - خودڪار طريقي جي مسئلن کي حل ڪرڻ لاء ڪوڊ جي پيداوار.