JSON ජාවා හි විග්‍රහ කරන්නේ කෙසේද


1071

මට පහත JSON පෙළ ඇත. මම කොහොමද වටිනාකම් ලබා ගැනීමට එය විග්රහ කළ හැකි pageName, pagePic, post_id, ආදිය?

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    },
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

7
ජාවා JSON පුස්තකාලවල ගොඩනගා ඇත්තේ ඒ සඳහා ඉක්මන්ම ක්‍රමයයි, නමුත් මගේ අත්දැකීම් අනුව GSON යනු JSON එකක් වේදනා රහිතව POJO එකකට විග්‍රහ කිරීම සඳහා හොඳම පුස්තකාලයයි.
ඉමාන් අක්බාරි

20
වඩාත්ම ඡන්දය දුන් සහ ආරක්‍ෂිත ප‍්‍රශ්නය මෙයයි. කාගේ පිළිතුරු මට වඩාත්ම අවුල්
සහගතද

6
Ays ජේසන් මිනාර්ඩ් එකඟ විය. මෝඩ මැදිහත් වීමක් ඉල්ලා ඇත. මෙය සැබවින්ම වසා දැමිය යුතුය. ප්‍රශ්නය මුලින් ආරක්‍ෂා කර තිබියදී මට එය කළ නොහැකි යැයි මම මුලින් උපකල්පනය කළෙමි (එබැවින්) මම එය අනාරක්‍ෂිත කර මගේ කාර්යය කළෙමි. මෝඩයක් බලාපොරොත්තුවෙන් සිටියදී අඩු ප්‍රතිචාර දැක්වීම වැළැක්වීම සඳහා දැන් එය නැවත ආරක්‍ෂා කර ඇත.
මෙනා

4
"මෙම ප්‍රශ්නය කිසිදු පර්යේෂණ ප්‍රයත්නයක් නොපෙන්වයි" - Downvote බොත්තම් මෙවලම්
ජීන්-ප්‍රංශුවා කෝබට්

6
මෙම ප්‍රශ්නය මෙටා හි සාකච්ඡා කෙරෙමින් පවතී .
මාර්ක් අමරි

Answers:


765

මෙම org.json පුස්තකාලය භාවිතා කිරීම පහසු වේ. උදාහරණ කේතය පහතින්:

import org.json.*;

String jsonString = ... ; //assign your JSON String here
JSONObject obj = new JSONObject(jsonString);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

ඔබට තවත් උදාහරණ සොයාගත හැකිය: ජාවා හි JSON විග්‍රහ කරන්න

බාගත කළ හැකි බඳුන: http://mvnrepository.com/artifact/org.json/json


15
මම @ ස්ටැක්ස්මන් සමඟ එකඟ වෙමි. මම org.json අත්හදා බැලුවෙමි. උදාහරණයක් ලෙස එය සම්මත ජාවා එකතු කිරීමේ වර්ග සමඟ ක්‍රියා නොකරයි.
කෙන් විලියම්ස්

7
@ ස්ටැක්ස්මන් org.jsonසරල JSON විග්‍රහ කිරීම සඳහා වෙනත් පුස්තකාලවලට වඩා මම තෝරා නොගනිමි . ඩග්ලස් ක්‍රොක්ෆර්ඩ් (JSON සොයාගැනීම) විසින් නිර්මාණය කරන ලද විමර්ශන පුස්තකාලය එයයි.
ඕමාර් අල්-ඉතාවි

31
@ ඕමරිතාවි එය මෝඩ වැඩකි. එය අමුතු API, අකාර්යක්ෂම ලෙස ක්‍රියාත්මක කිරීම සමඟ සංකල්පයේ සාධනයකි. පුස්තකාල එහි කතුවරුන්ගේ දෘශ්‍යතාවයෙන් ගුණාත්මක භාවය අඩු කිරීමට උත්සාහ කරනවා වෙනුවට ඔවුන්ගේම සුදුසුකම් මත සලකා බැලීම වඩා හොඳ යැයි මම සිතමි - ඩග් බොහෝ දේ අත්කර ගෙන ඇත, නමුත් එය ඇත්ත වශයෙන්ම එම ලිබයේ ගුණාංග වෙනස් නොකරයි. මීට වසර 10 කට පෙර එය නගරයේ එකම ක්‍රීඩාව වූ නමුත් එතැන් සිට බොහෝ ධනාත්මක ප්‍රගතියක් ලබා ඇත. එය ස්ට්රට්ස් ඔෆ් ජේසන් ලිබ්ස් වැනි ය.
ස්ටැක්ස්මන්

12
org.json නරකම json පුස්තකාල අතර වේ. තෝරා ගැනීමට පෙර ලබා ගත හැකි json පුස්තකාලවල විශේෂාංග කට්ටලය සහ ක්‍රියාකාරීත්වය දෙස බැලිය යුතුය. මෙන්න මම ජැක්සන්, ග්සන්, ඕර්ග්.ජොන්, ජෙන්සන්, ජේඑම්එච් භාවිතා කරමින් සංසන්දනය කළ මිණුම් ලකුණක්: github.com/fabienrenaud/java-json-benchmark . ජැක්සන් මෙහි පැහැදිලි ජයග්‍රාහකයා වේ.
ෆේබියන්

4
බලපත්‍රයේ බහුලව භාවිතා වන විවෘත මූලාශ්‍ර බලපත්‍රයක් ඇතුළත් නොවන අතර එය ප්‍රකාශන හිමිකම ද දරයි.
ක්‍රිස්ටියන් විල්මා

543

උදාහරණය සඳහා ඔබට පන්තියක් ඇතැයි උපකල්පනය කරමු Person පමණක් සමඟ name.

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

ගූගල් GSON ( ලැබෙන කව්ලුවේ )

ශ්‍රේෂ් J JSON අනුක්‍රමිකකරණය / වස්තු අනුක්‍රමිකකරණය කිරීම මගේ පුද්ගලික ප්‍රියතමය.

Gson g = new Gson();

Person person = g.fromJson("{\"name\": \"John\"}", Person.class);
System.out.println(person.name); //John

System.out.println(g.toJson(person)); // {"name":"John"}

යාවත්කාලීන කරන්න

ඔබට තනි ලක්ෂණයක් ලබා ගැනීමට අවශ්‍ය නම් ඔබට එය ගූගල් පුස්තකාලය සමඟ පහසුවෙන් කළ හැකිය:

JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject();

System.out.println(jsonObject.get("name").getAsString()); //John

Org.JSON ( ලැබෙන කව්ලුවේ )

ඔබට වස්තු-අනුක්‍රමිකකරණය අවශ්‍ය නොව, හුදෙක් ලක්ෂණයක් ලබා ගැනීමට නම්, ඔබට org.json උත්සාහ කළ හැකිය ( නැතහොත් ඉහත GSON උදාහරණය බලන්න! )

JSONObject obj = new JSONObject("{\"name\": \"John\"}");

System.out.println(obj.getString("name")); //John

ජැක්සන් ( මේවන් )

ObjectMapper mapper = new ObjectMapper();
Person user = mapper.readValue("{\"name\": \"John\"}", Person.class);

System.out.println(user.name); //John

16
හොඳ පිළිතුරක්. සුළු වැඩිදියුණු කිරීම සඳහා එක් යෝජනාවක්: GSON සහ ජැක්සන් යන දෙදෙනාම JSON ගස් නිරූපණය භාවිතා කිරීමට සහාය දක්වයි (ජැක්සන්ට මේවා JsonNodes, GSON ට සමාන දෙයක් තිබේ). Org.json පිරිනමන එකම ක්‍රමයට සමාන බැවින්, ස්නිපෙට් පෙන්වීමට හොඳ විය හැකිය.
ස්ටැක්ස්මන්

සඳහන් කළ යුතු තවත් පුස්තකාල දෙකක් (සම්පූර්ණත්වය සඳහා): json-simple සහ Oracle's JSONP
jake stayman

3
E නියොන්වර්ජ්, ඇයි? මෙම පිළිතුර යමෙකු දැනටමත් JSON නූලට සමාන ක්ෂේත්‍ර අඩංගු ජාවා පන්තියක් නිර්වචනය කර ඇති බව මට පෙනේ, ඊට වඩා අඩු කිසිවක් නැත. මෙය තරමක් ශක්තිමත් උපකල්පනයකි.
ඇන්ඩ්‍රියා ලාසරෝටෝ

1
json-simple සහ oracle's jsonp ඉතා භයානක ලෙස ක්‍රියා කරයි: github.com/fabienrenaud/java-json-benchmark කාර්ය සාධනය සඳහා, ජැක්සන් හෝ dsljson තෝරන්න.
ෆැබියන්

මූල හැර වෙනත් මට්ටම්වල ක්ෂේත්‍ර ගතිකව පෙරීමට GSON සහාය නොදක්වයි!
ගන්ග්නස්

103
  1. යමෙකුට JSON වෙතින් ජාවා වස්තුවක් නිර්මාණය කිරීමට අවශ්‍ය නම් සහ අනෙක් අතට, GSON හෝ JACKSON තෙවන පාර්ශවීය භාජන ආදිය භාවිතා කරන්න.

    //from object to JSON 
    Gson gson = new Gson();
    gson.toJson(yourObject);
    
    // from JSON to object 
    yourObject o = gson.fromJson(JSONString,yourObject.class);
  2. නමුත් යමෙකුට JSON නූලක් විග්‍රහ කර යම් අගයන් ලබා ගැනීමට අවශ්‍ය නම්, (නැතහොත් වයර් හරහා යැවීම සඳහා මුල සිටම JSON නූලක් සාදන්න) JsonEE / jsonArray, JsonObject ආදිය අඩංගු JaveEE භාජනය භාවිතා කරන්න. ඔබට එය ක්‍රියාත්මක කිරීම බාගත කිරීමට අවශ්‍ය විය හැකිය. javax.json වැනි පිරිවිතර. මෙම භාජන දෙක සමඟ මට json විග්‍රහ කර අගයන් භාවිතා කළ හැකිය.

    මෙම ඒපීඅයි ඇත්ත වශයෙන්ම XML හි DOM / SAX විග්‍රහ කිරීමේ ආකෘතිය අනුගමනය කරයි.

    Response response = request.get(); // REST call 
        JsonReader jsonReader = Json.createReader(new StringReader(response.readEntity(String.class)));
        JsonArray jsonArray = jsonReader.readArray();
        ListIterator l = jsonArray.listIterator();
        while ( l.hasNext() ) {
              JsonObject j = (JsonObject)l.next();
              JsonObject ciAttr = j.getJsonObject("ciAttributes");

4
ndnondescript මට අනුමාන කිරීමට සිදුවුවහොත් එය පහත් කොට ඇති බව මම කියමි, එය මුල් පෝස්ටරයේ ප්‍රශ්නයට පිළිතුරු නොදෙන නිසා: "අවශ්‍ය කේතය කුමක්ද?" ඉහළට ඔසවා ඇති පිළිතුරු කේත ස්නිපෙට් සපයයි.
jewbix.cube

4
සටහන: ජැක්සන් සහ ජීඑස්ඕඑන් යන දෙදෙනාම ගස් විලාසිතාවට සහ / හෝ සිතියම් / ලැයිස්තු බන්ධනයට සහාය දක්වයි, එබැවින් ජාවා ඊඊ (javax.json) පැකේජය භාවිතා කිරීම අවශ්‍ය නොවේ. javax.json හට ජැක්සන්ට හෝ GSON ට වඩා වැඩි යමක් ඉදිරිපත් කළ නොහැක.
ස්ටැක්ස්මන්

ජාවාඊ පුස්තකාලයට සබැඳියක් එක් කිරීමට මම යෝජනා කරමි.
බැසිල් බෝර්ක්

72

quick-json විග්‍රහකය ඉතා සරල, නම්‍යශීලී, ඉතා වේගවත් හා අභිරුචිකරණය කළ හැකිය. උත්සහ කරන්න

විශේෂාංග:

  • JSON පිරිවිතරයට අනුකූල වේ (RFC4627)
  • ඉහළ කාර්ය සාධනය JSON විග්‍රහකය
  • නම්යශීලී / වින්‍යාසගත කළ හැකි විග්‍රහ කිරීමේ ප්‍රවේශයට සහය දක්වයි
  • ඕනෑම JSON ධූරාවලියක යතුරු / අගය යුගල වින්‍යාසගත කළ හැකි වලංගු කිරීම
  • භාවිතා කිරීමට පහසු # ඉතා කුඩා අඩිපාර
  • සංවර්ධක හිතකාමී සහ ව්‍යතිරේක සොයා ගැනීමට පහසුය
  • ප්ලග් කළ හැකි අභිරුචි වලංගුකරණ සහාය - අභිරුචි වලංගු කරන්නන් වින්‍යාස කිරීමෙන් යතුරු / අගයන් වලංගු කළ හැකිය.
  • වලංගු කිරීමේ සහ වලංගු නොවන පාර්සර් සහාය
  • ඉක්මන්- JSON වලංගු කිරීමේ විග්‍රහකය භාවිතා කිරීම සඳහා වින්‍යාසකරණ වර්ග දෙකකට (JSON / XML) සහාය
  • JDK 1.5 අවශ්‍යයි
  • බාහිර පුස්තකාල මත යැපීමක් නැත
  • වස්තු අනුක්‍රමිකකරණය හරහා JSON උත්පාදනය සඳහා සහාය
  • විග්‍රහ කිරීමේ ක්‍රියාවලියේදී එකතු කිරීමේ වර්ගය තෝරා ගැනීම සඳහා සහාය

එය මේ ආකාරයෙන් භාවිතා කළ හැකිය:

JsonParserFactory factory=JsonParserFactory.getInstance();
JSONParser parser=factory.newJsonParser();
Map jsonMap=parser.parseJson(jsonString);

3
ජාවාඩොක් තිබේද?
jboi

24
විග්‍රහ කිරීමේදී මෙම පැකේජයට හිස් අගයන් හැසිරවිය නොහැක. උදාහරණයක් ලෙස: ... "විස්තරය": "" ... ව්‍යතිරේකයක් විසි කරයි
අයිවන්

6
මම මෙම ගැටළුව (සහ තවත් බොහෝ අය) code.google.com/p/quick-json/issues/detail?id=11 හි විසඳා ඇත්තෙමි. නිල නිකුතුවේදී එය නිවැරදි කිරීමට කතුවරයා කාලය ලබා දෙනු ඇතැයි මම බලාපොරොත්තු වෙමි.
noamik

8
ලැයිස්තුගත කර ඇති විශේෂාංග වලින්, වෙනත් විකල්ප සමඟ සසඳන විට කිසිවක් අද්විතීය නොවේ - සහ ඉහළ කාර්යසාධනයක් සඳහා හිමිකම් පෑමට කිසිවක් සහාය නොදක්වයි; සඳහා මෙන් නොව පරිණත පුස්තකාල වැනි මිනුම් දඬු ඇතුළත් කරන (Gson, ජැක්සන් Genson, බූන්) වැඩි github.com/eishay/jvm-serializers , github.com/novoj/JavaJsonPerformanceTest හෝ developer.com/lang/jscript/... - මම මෙම පුස්තකාලය පරීක්ෂණවලට ඇතුළත් කර ඇති බවක් හෝ එය බහුලව භාවිතා වන බව සඳහන් කර නැත.
ස්ටැක්ස්මන්

27
මෙම ව්‍යාපෘතිය මිය ගොස් ඇති බවක් පෙනෙන්නට ඇති අතර එය තවදුරටත් මධ්‍යම මාවන් ගබඩාවේ සත්කාරක නොවන බව පෙනේ.
8bitjunkie

42

ඔබට ගූගල් ග්සන් භාවිතා කළ හැකිය .

මෙම පුස්තකාලය භාවිතා කිරීමෙන් ඔබට අවශ්‍ය වන්නේ එකම JSON ව්‍යුහයක් සහිත ආකෘතියක් නිර්මාණය කිරීමයි. එවිට ආකෘතිය ස්වයංක්‍රීයව පුරවනු ලැබේ. ඔබේ විචල්‍යයන් ඔබේ JSON යතුරු ලෙස හැඳින්විය යුතුය, නැතහොත් @SerializedNameඔබට විවිධ නම් භාවිතා කිරීමට අවශ්‍ය නම් භාවිතා කරන්න.

JSON

ඔබේ උදාහරණයෙන්:

{
    "pageInfo": {
        "pageName": "abc",
        "pagePic": "http://example.com/content.jpg"
    }
    "posts": [
        {
            "post_id": "123456789012_123456789012",
            "actor_id": "1234567890",
            "picOfPersonWhoPosted": "http://example.com/photo.jpg",
            "nameOfPersonWhoPosted": "Jane Doe",
            "message": "Sounds cool. Can't wait to see it!",
            "likesCount": "2",
            "comments": [],
            "timeOfPost": "1234567890"
        }
    ]
}

ආකෘතිය

class MyModel {

    private PageInfo pageInfo;
    private ArrayList<Post> posts = new ArrayList<>();
}

class PageInfo {

    private String pageName;
    private String pagePic;
}

class Post {

    private String post_id;

    @SerializedName("actor_id") // <- example SerializedName
    private String actorId;

    private String picOfPersonWhoPosted;
    private String nameOfPersonWhoPosted;
    private String message;
    private String likesCount;
    private ArrayList<String> comments;
    private String timeOfPost;
}

විග්‍රහ කිරීම

දැන් ඔබට Gson පුස්තකාලය භාවිතයෙන් විග්‍රහ කළ හැකිය:

MyModel model = gson.fromJson(jsonString, MyModel.class);

ශ්‍රේණියේ ආනයනය

යෙදුම් ග්‍රෙඩ්ල් ගොනුවේ පුස්තකාලය ආයාත කිරීමට මතක තබා ගන්න

implementation 'com.google.code.gson:gson:2.8.6' // or earlier versions

ස්වයංක්‍රීය ආකෘති උත්පාදනය

මේ වගේ මාර්ගගත මෙවලම් භාවිතයෙන් ඔබට ස්වයංක්‍රීයව JSON වෙතින් ආකෘතියක් ජනනය කළ හැකිය .


39

ලබා දී ඇති සෑම පිළිතුරකටම පාහේ පොලී දේපලෙහි වටිනාකමට ප්‍රවේශ වීමට පෙර JSON ජාවා වස්තුවකට පූර්ණ ලෙස අවලංගු කිරීම අවශ්‍ය වේ. මෙම මාර්ගයට නොයන තවත් විකල්පයක් වන්නේ JsonPATH භාවිතා කිරීමයි JSON සඳහා XPath වැනි සහ JSON වස්තු ගමන් කිරීමට ඉඩ .

එය පිරිවිතරයක් වන අතර ජේවේ හි හොඳ පුද්ගලයින් ඔබට මෙහි සොයාගත හැකි පිරිවිතරයන් සඳහා ජාවා ක්‍රියාත්මක කිරීමක් නිර්මාණය කර ඇත: https://github.com/jayway/JsonPath

එබැවින් මූලික වශයෙන් එය භාවිතා කිරීමට, එය ඔබේ ව්‍යාපෘතියට එක් කරන්න, උදා:

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>${version}</version>
</dependency>

සහ භාවිතා කිරීමට:

String pageName = JsonPath.read(yourJsonString, "$.pageInfo.pageName");
String pagePic = JsonPath.read(yourJsonString, "$.pageInfo.pagePic");
String post_id = JsonPath.read(yourJsonString, "$.pagePosts[0].post_id");

etc ...

JSON තීර්යක් කිරීමට ඇති වෙනත් ක්‍රම පිළිබඳ වැඩි විස්තර සඳහා JsonPath පිරිවිතර පිටුව පරීක්ෂා කරන්න.


මෙය ඉතා හොඳ පුස්තකාලයක් වන අතර විශේෂයෙන් JSON කියවීම සහ යාවත්කාලීන කිරීම සඳහා වන නමුත් මෙම පුස්තකාලය පිළිබඳ දන්නා යම් කාරණයක් ගැන පරිස්සම් වන්න. [1] බලන්න: github.com/json-path/JsonPath/issues/272 [2]: github.com/json-path/JsonPath/issues/375
papigee

38

A - පැහැදිලි කිරීම

JSON String POJO ( Plain Old Java Object ) අවස්ථාවන්ට බැඳීම සඳහා ඔබට ජැක්සන් පුස්තකාල භාවිතා කළ හැකිය . POJO යනු හුදෙක් පුද්ගලික ක්ෂේත්‍ර සහ පොදු ලබා ගැනීමේ / සැකසුම් ක්‍රම ඇති පන්තියකි. ජැක්සන් ක්‍රමවේදයන් ( පරාවර්තනය භාවිතා කරමින් ) ගමන් කිරීමට යන අතර, පන්තියේ ක්ෂේත්‍ර නාම JSON වස්තුවේ ක්ෂේත්‍ර නාමයන්ට ගැලපෙන පරිදි JSON වස්තුව POJO නිදසුනට සිතියම් ගත කරයි.

සැබවින්ම සංයුක්ත වස්තුවක් වන ඔබේ JSON වස්තුව තුළ, ප්‍රධාන වස්තුව උප වස්තු දෙකකින් සමන්විත වේ. ඉතින්, අපගේ POJO පන්තිවලට එකම ධූරාවලියක් තිබිය යුතුය. මම මුළු JSON වස්තුව පිටු වස්තුව ලෙස හඳුන්වන්නෙමි . පිටු වස්තුව පේජ්ඉන්ෆෝ වස්තුවකින් සහ පශ්චාත් වස්තු අරාවකින් සමන්විත වේ.

එබැවින් අපි වෙනස් POJO පන්ති තුනක් නිර්මාණය කළ යුතුය;

  • පේජ් ඉන්ෆෝ පංතියේ සංයුක්තයක් වන පේජ් ක්ලාස් සහ පශ්චාත් අවස්ථා පෙළ
  • PageInfo පන්තිය
  • තනතුරු පන්තිය

මා භාවිතා කළ එකම පැකේජය වන්නේ ජැක්සන් ObjectMapper, අප කරන්නේ දත්ත බන්ධනය කිරීමයි;

com.fasterxml.jackson.databind.ObjectMapper

අවශ්‍ය පරායත්තතා, භාජන ගොනු පහත ලැයිස්තු ගත කර ඇත;

  • jackson-core-2.5.1.jar
  • jackson-databaseind-2.5.1.jar
  • jackson-annotations-2.5.0.jar

මෙන්න අවශ්‍ය කේතය;

B - ප්‍රධාන POJO පන්තිය: පිටුව

package com.levo.jsonex.model;

public class Page {

    private PageInfo pageInfo;
    private Post[] posts;

    public PageInfo getPageInfo() {
        return pageInfo;
    }

    public void setPageInfo(PageInfo pageInfo) {
        this.pageInfo = pageInfo;
    }

    public Post[] getPosts() {
        return posts;
    }

    public void setPosts(Post[] posts) {
        this.posts = posts;
    }

}

සී - ළමා POJO පන්තිය: PageInfo

package com.levo.jsonex.model;

public class PageInfo {

    private String pageName;
    private String pagePic;

    public String getPageName() {
        return pageName;
    }

    public void setPageName(String pageName) {
        this.pageName = pageName;
    }

    public String getPagePic() {
        return pagePic;
    }

    public void setPagePic(String pagePic) {
        this.pagePic = pagePic;
    }

}

ඩී - ළමා පොජෝ පන්තිය: තනතුර

package com.levo.jsonex.model;

public class Post {

    private String post_id;
    private String actor_id;
    private String picOfPersonWhoPosted;
    private String nameOfPersonWhoPosted;
    private String message;
    private int likesCount;
    private String[] comments;
    private int timeOfPost;

    public String getPost_id() {
        return post_id;
    }

    public void setPost_id(String post_id) {
        this.post_id = post_id;
    }

    public String getActor_id() {
        return actor_id;
    }

    public void setActor_id(String actor_id) {
        this.actor_id = actor_id;
    }

    public String getPicOfPersonWhoPosted() {
        return picOfPersonWhoPosted;
    }

    public void setPicOfPersonWhoPosted(String picOfPersonWhoPosted) {
        this.picOfPersonWhoPosted = picOfPersonWhoPosted;
    }

    public String getNameOfPersonWhoPosted() {
        return nameOfPersonWhoPosted;
    }

    public void setNameOfPersonWhoPosted(String nameOfPersonWhoPosted) {
        this.nameOfPersonWhoPosted = nameOfPersonWhoPosted;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public int getLikesCount() {
        return likesCount;
    }

    public void setLikesCount(int likesCount) {
        this.likesCount = likesCount;
    }

    public String[] getComments() {
        return comments;
    }

    public void setComments(String[] comments) {
        this.comments = comments;
    }

    public int getTimeOfPost() {
        return timeOfPost;
    }

    public void setTimeOfPost(int timeOfPost) {
        this.timeOfPost = timeOfPost;
    }

}

ඊ - නියැදි JSON ගොනුව: sampleJSONFile.json

මම ඔබගේ JSON නියැදිය මෙම ගොනුවට පිටපත් කර ව්‍යාපෘති ෆෝල්ඩරය යටතේ තබා ඇත.

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    },
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

එෆ් - ආදර්ශන කේතය

package com.levo.jsonex;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.levo.jsonex.model.Page;
import com.levo.jsonex.model.PageInfo;
import com.levo.jsonex.model.Post;

public class JSONDemo {

    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            Page page = objectMapper.readValue(new File("sampleJSONFile.json"), Page.class);

            printParsedObject(page);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private static void printParsedObject(Page page) {
        printPageInfo(page.getPageInfo());
        System.out.println();
        printPosts(page.getPosts());
    }

    private static void printPageInfo(PageInfo pageInfo) {
        System.out.println("Page Info;");
        System.out.println("**********");
        System.out.println("\tPage Name : " + pageInfo.getPageName());
        System.out.println("\tPage Pic  : " + pageInfo.getPagePic());
    }

    private static void printPosts(Post[] posts) {
        System.out.println("Page Posts;");
        System.out.println("**********");
        for(Post post : posts) {
            printPost(post);
        }
    }

    private static void printPost(Post post) {
        System.out.println("\tPost Id                   : " + post.getPost_id());
        System.out.println("\tActor Id                  : " + post.getActor_id());
        System.out.println("\tPic Of Person Who Posted  : " + post.getPicOfPersonWhoPosted());
        System.out.println("\tName Of Person Who Posted : " + post.getNameOfPersonWhoPosted());
        System.out.println("\tMessage                   : " + post.getMessage());
        System.out.println("\tLikes Count               : " + post.getLikesCount());
        System.out.println("\tComments                  : " + Arrays.toString(post.getComments()));
        System.out.println("\tTime Of Post              : " + post.getTimeOfPost());
    }

}

ජී - ආදර්ශන ප්‍රතිදානය

Page Info;
****(*****
    Page Name : abc
    Page Pic  : http://example.com/content.jpg
Page Posts;
**********
    Post Id                   : 123456789012_123456789012
    Actor Id                  : 1234567890
    Pic Of Person Who Posted  : http://example.com/photo.jpg
    Name Of Person Who Posted : Jane Doe
    Message                   : Sounds cool. Can't wait to see it!
    Likes Count               : 2
    Comments                  : []
    Time Of Post              : 1234567890

27

අවම-ජේසන් භාවිතා කරන්න, එය ඉතා වේගවත් හා භාවිතා කිරීමට පහසුය. ඔබට String obj සහ Stream වෙතින් විග්‍රහ කළ හැකිය.

නියැදි දත්ත:

{
  "order": 4711,
  "items": [
    {
      "name": "NE555 Timer IC",
      "cat-id": "645723",
      "quantity": 10,
    },
    {
      "name": "LM358N OpAmp IC",
      "cat-id": "764525",
      "quantity": 2
    }
  ]
}

විග්‍රහ කිරීම:

JsonObject object = Json.parse(input).asObject();
int orders = object.get("order").asInt();
JsonArray items = object.get("items").asArray();

JSON නිර්මාණය කිරීම:

JsonObject user = Json.object().add("name", "Sakib").add("age", 23);

මේවන්:

<dependency>
  <groupId>com.eclipsesource.minimal-json</groupId>
  <artifactId>minimal-json</artifactId>
  <version>0.9.4</version>
</dependency>

පූජෝ පෙනෙන්නේ කෙසේද?
ජෙසී

Pojo සඳහා gson භාවිතා කරන්න. මෙම පුස්තකාලය සහාය නොදක්වයි.
සකීබ් සාමි

23

හොඳම ක්‍රියාව විය යුත්තේ තවමත් ක්‍රියාත්මක වෙමින් පවතින නිල ජාවා JSON API හරහා යාමයි .


7
මම පිළිතුරු දුන් දා සිට, මම ජැක්සන් භාවිතා කිරීමට පටන් ගත් අතර එය JSON de-serialization සඳහා ඇති හොඳම පුස්තකාලවලින් එකක් යැයි මම සිතමි.
ජියෝවානි බොටා

2
පැඩිං සමඟ JSON ට වඩා වෙනස් දෙයක් අදහස් කිරීමට ඔවුන් JSONP නැවත භාවිතා කරන්නේ ඇයි? ...
ක්‍රිස් වෙසලින්

H ක්‍රිස්වෙස්ලිං ඔබ අදහස් කළේ කුමක්ද?
ජියෝවානි බොටා

"JSON සැකසුම් සඳහා ජාවා API (JSON-P)" යනු ඔබ සම්බන්ධ කරන ලේඛනයේ මාතෘකාවයි. එය මා ව්‍යාකූල කළේ, මම වෙනත් දෙයක් අදහස් කිරීමට JSONP දැන සිටි බැවිනි.
ක්‍රිස් වෙසලින්

1
H ක්‍රිස්වෙස්ලිං ඔහ් එය අවුල් සහගතය. පිරිවිතර සඳහා ඔවුන් තෝරාගත්තේ එයයි. කෙසේ වෙතත්, මම කී පරිදි, මම කෙලින්ම ජැක්සන් වෙත යන්නෙමි.
ජියෝවානි බොටා

23

කිසිවෙකු තවම එය සඳහන් කර නැති නිසා, මෙන්න නෂෝර්න් (ජාවා 8 හි ජාවාස්ක්‍රිප්ට් ධාවන කාල කොටස, නමුත් ජාවා 11 හි ඉවත් කර ඇත) භාවිතා කරමින් විසඳුමක ආරම්භයයි .

විසඳුමක්

private static final String EXTRACTOR_SCRIPT =
    "var fun = function(raw) { " +
    "var json = JSON.parse(raw); " +
    "return [json.pageInfo.pageName, json.pageInfo.pagePic, json.posts[0].post_id];};";

public void run() throws ScriptException, NoSuchMethodException {
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    engine.eval(EXTRACTOR_SCRIPT);
    Invocable invocable = (Invocable) engine;
    JSObject result = (JSObject) invocable.invokeFunction("fun", JSON);
    result.values().forEach(e -> System.out.println(e));
}

කාර්ය සාධනය සංසන්දනය

මම JSON අන්තර්ගතය පිළිවෙලින් මූලද්‍රව්‍ය 20, 20 සහ 100 අරා තුනක් අඩංගු විය. මට අවශ්‍ය වන්නේ තුන්වන අරාවෙන් මූලද්‍රව්‍ය 100 ලබා ගැනීමට පමණි. මගේ සටහන් විග්‍රහ කර ලබා ගැනීමට මම පහත ජාවාස්ක්‍රිප්ට් ශ්‍රිතය භාවිතා කරමි.

var fun = function(raw) {JSON.parse(raw).entries};

නෂෝර්න් භාවිතයෙන් මිලියනය වතාවක් ඇමතුම ධාවනය කිරීමට තත්පර 7.5 ~ 7.8 ක් ගතවේ

(JSObject) invocable.invokeFunction("fun", json);

org.json තත්පර 20 ~ 21 ක් ගතවේ

new JSONObject(JSON).getJSONArray("entries");

ජැක්සන්ට තත්පර 6.5 ~ 7 ක් ගතවේ

mapper.readValue(JSON, Entries.class).getEntries();

මෙම අවස්ථාවේ දී ජැක්සන් නෂෝර්න්ට වඩා හොඳින් ක්‍රියා කරයි, එය org.json ට වඩා හොඳින් ක්‍රියා කරයි. Ng.horn API org.json හෝ ජැක්සන්ගේ භාවිතා කිරීමට වඩා අපහසුය. ඔබගේ අවශ්‍යතා මත පදනම්ව ජැක්සන් සහ නෂෝර්න් යන දෙදෙනාම ශක්‍ය විසඳුම් විය හැකිය.


2
ඒකකය යනු "කුමක්ද? අඟල් නොවේද? එය තත්පර ද? මිනිත්තු?
පීටර් මෝර්ටෙන්සන්

2
EtPeterMortensen යන්නෙන් අදහස් වන්නේ තත්පර. එය අපැහැදිලි බැවින් මම එය වෙනස් කරමි. සමාලෝචනයට ස්තූතියි.
otonglet

2
අවාසනාවකට මෙන්, නෂෝර්න් ජාවා 11 හි ඉවත් කර ඇත. JEP 335 .
මිල්ඩ්නර්ට

2
මම දන්නවා නෂෝර්න් අතහැර දමා ඇති බව, නමුත් මම මෙම පිළිතුරට කැමති වූයේ මට කිසිදු පරායත්තතාවයක් අවශ්‍ය නැති නිසා; කෙසේ වෙතත්, මට උදාහරණය ටිකක් නැවත වැඩ කිරීමට සිදු විය:ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript"); engine.eval("var fun = function(raw) { return JSON.parse(raw); };"); Map<String, Object> json = (Map<String, Object>) ((Invocable) engine).invokeFunction("fun", jsonString);
kgibm

gkgibm නියමයි! Objectආපසු ලබා දුන් අරා මූලද්‍රව්‍ය වෙත ප්‍රවේශ වන්නේ කෙසේදැයි ඔබ දන්නවාද ? පංතිය ScriptObjectMirrorනමුත් එයට ප්‍රවේශ විය නොහැක ...
මතෙව්

21

පහත උදාහරණයෙන් දැක්වෙන්නේ "jsonText" විචල්‍යය ලෙස නිරූපණය වන ප්‍රශ්නයේ පෙළ කියවන ආකාරයයි. මෙම විසඳුම ජාවා ඊඊ 7 javax.json API භාවිතා කරයි (එය වෙනත් පිළිතුරු වල සඳහන් වේ). මා එය වෙනම පිළිතුරක් ලෙස එකතු කිරීමට හේතුව පහත දැක්වෙන කේතය මඟින් ප්‍රශ්නයේ පෙන්වා ඇති සමහර අගයන්ට සත්‍ය වශයෙන්ම ප්‍රවේශ වන්නේ කෙසේද යන්නයි . ක ද javax.json API ක්රියාත්මක මෙම කේතය ලකුණු කල යුතු ය. "ආනයන" ප්‍රකාශ ප්‍රකාශ කිරීමට මට අවශ්‍ය නැති නිසා අවශ්‍ය සෑම පන්තියක් සඳහාම සම්පූර්ණ පැකේජය ඇතුළත් විය.

javax.json.JsonReader jr = 
    javax.json.Json.createReader(new StringReader(jsonText));
javax.json.JsonObject jo = jr.readObject();

//Read the page info.
javax.json.JsonObject pageInfo = jo.getJsonObject("pageInfo");
System.out.println(pageInfo.getString("pageName"));

//Read the posts.
javax.json.JsonArray posts = jo.getJsonArray("posts");
//Read the first post.
javax.json.JsonObject post = posts.getJsonObject(0);
//Read the post_id field.
String postId = post.getString("post_id");

දැන්, කිසිවෙකු ගොස් මෙම පිළිතුර අවතක්සේරු කිරීමට පෙර එය GSON, org.json, ජැක්සන් හෝ වෙනත් තෙවන පාර්ශවීය රාමු භාවිතා නොකරන නිසා, ලබා දී ඇති පෙළ විග්‍රහ කිරීම සඳහා ප්‍රශ්නයකට “අවශ්‍ය කේත” සඳහා උදාහරණයකි. වර්තමාන ප්‍රමිතිය වන ජේඑස්ආර් 353 පිළිපැදීම ජේඩීකේ 9 සඳහා සලකා බලනු නොලබන බව මම හොඳින් දනිමි. එබැවින් ජේඑස්ආර් 353 පිරිවිතර වෙනත් ඕනෑම තෙවන පාර්ශවීය ජේඑස්ඕඑන් හැසිරවීමේ ක්‍රියාවලියට සමාන විය යුතුය.


15

මෙය කොතරම් පහසුද යන්න මගේ මනස පුපුරා ගියේය. Stringසුපුරුදු org.json පැකේජයේ ඇති JSONObject හි ඉදිකිරීම්කරු වෙත ඔබේ JSON රඳවා තබා ගත හැකිය .

JSONArray rootOfPage =  new JSONArray(JSONString);

සිදු විය. මයික්‍රෝෆෝනය පහත වැටේ . මෙයද ක්‍රියාත්මක JSONObjectsවේ. ඊට පසු, ඔබට ඔබේ වස්තූන් මත Objectsඇති get()ක්‍රම භාවිතා කිරීමේ ධූරාවලිය දෙස බැලිය හැකිය.


13
මෙම JSONArrayවර්ගයේ J2SE JDK API කොටසක් නොවන අතර ඔබ මෙම වර්ගය සපයන API හෝ තෙවන පාර්ශවීය පුස්තකාලය කියන්නේ නැහැ.
බොබුලස්

2
මම එය භාවිතා කිරීම නිර්දේශ කළේ නැත, නමුත් මම මේ කාලය තුළ "org.json" පැකේජය හඳුන්වා හිතන්නේ json.org/java . හොඳ ජාවා පුස්තකාල ලබා ගැනීමට පෙර එය භාවිතා කරන ලදී, නමුත් මෙය මීට වසර ගණනාවකට පෙර (2008 හෝ ඊට පෙර)
StaxMan

1
නැතිනම් මොළය 1 යනු ඇන්ඩ්‍රොයිඩ් හි JSONArray යන්නද ?
ඇලෙක්සැන්ඩර් ෆාබර්

12

ජාවා හි බොහෝ JSON පුස්තකාල තිබේ.

වඩාත්ම කුප්‍රකට ඒවා නම්: ජැක්සන්, ජීඑස්ඕඑන්, ජෙන්සන්, ෆාස්ට් ජේසන් සහ org.json.

ඕනෑම පුස්තකාලයක් තෝරා ගැනීම සඳහා සාමාන්‍යයෙන් අවධානය යොමු කළ යුතු කරුණු තුනක් තිබේ:

  1. කාර්ය සාධනය
  2. භාවිතයේ පහසුව (කේතය ලිවීමට සරල සහ පැහැදිලි ය) - එය විශේෂාංග සමඟ යයි.
  3. ජංගම යෙදුම් සඳහා: යැපීම / භාජන ප්‍රමාණය

විශේෂයෙන් JSON පුස්තකාල සඳහා (සහ ඕනෑම අනුක්‍රමික / ඩෙසරීලේෂන් ලිබ්), දත්ත ඇසුරුම් කිරීම සාමාන්‍යයෙන් උනන්දුවක් දක්වන්නේ දත්ත ඇසුරුම් කිරීමට / ඉවත් කිරීමට බොයිලර්-තහඩු කේතය ලිවීමේ අවශ්‍යතාවය ඉවත් කරන බැවිනි.

: 1, මෙම මිනුම් දන්ඩ බලන්න https://github.com/fabienrenaud/java-json-benchmark මම භාවිතා කළේ JMH ධාරාව භාවිතා serializers හා deserializers ක (ජැක්සන් gson, genson, fastjson, org.json, jsonp) කාර්ය සාධන සංසන්දනය කරන සහ දත්ත සමුදා API. 2 සඳහා, ඔබට අන්තර්ජාලයේ බොහෝ උදාහරණ සොයාගත හැකිය. ඉහත මිණුම් ලකුණ උදාහරණ ප්‍රභවයක් ලෙස ද භාවිතා කළ හැකිය ...

මිණුම් ලකුණ ඉක්මණින් ඉවත් කිරීම: ජැක්සන් org.json ට වඩා 5 සිට 6 ගුණයක් සහ GSON ට වඩා දෙගුණයකටත් වඩා හොඳින් ක්‍රියා කරයි.

ඔබේ විශේෂ උදාහරණය සඳහා, පහත කේතය ජැක්සන් සමඟ ඔබේ ජේසන් විකේතනය කරයි:

public class MyObj {

    private PageInfo pageInfo;
    private List<Post> posts;

    static final class PageInfo {
        private String pageName;
        private String pagePic;
    }

    static final class Post {
        private String post_id;
        @JsonProperty("actor_id");
        private String actorId;
        @JsonProperty("picOfPersonWhoPosted")
        private String pictureOfPoster;
        @JsonProperty("nameOfPersonWhoPosted")
        private String nameOfPoster;
        private String likesCount;
        private List<String> comments;
        private String timeOfPost;
    }

    private static final ObjectMapper JACKSON = new ObjectMapper();
    public static void main(String[] args) throws IOException {
        MyObj o = JACKSON.readValue(args[0], MyObj.class); // assumes args[0] contains your json payload provided in your question.
    }
}

ඔබට කිසියම් ප්‍රශ්නයක් ඇත්නම් මට දන්වන්න.


11

වෙනත් පිළිතුරු වලට අමතරව, JSON, ජැක්සන් 1.x හෝ ජැක්සන් 2.x සඳහා json හෝ json schema වෙතින් ජාවා පන්ති ඉක්මනින් උත්පාදනය කිරීම සඳහා මම මෙම මාර්ගගත විවෘත සේවා jsonschema2pojo.org නැවත නිර්දේශ කරමි . උදාහරණයක් ලෙස, ඔබට තිබේ නම්:

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    }
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": 1234567890,
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": 2,
              "comments": [],
              "timeOfPost": 1234567890
         }
    ]
}

මෙම jsonschema2pojo.org GSON ජනනය:

@Generated("org.jsonschema2pojo")
public class Container {
    @SerializedName("pageInfo")
    @Expose
    public PageInfo pageInfo;
    @SerializedName("posts")
    @Expose
    public List<Post> posts = new ArrayList<Post>();
}

@Generated("org.jsonschema2pojo")
public class PageInfo {
    @SerializedName("pageName")
    @Expose
    public String pageName;
    @SerializedName("pagePic")
    @Expose
    public String pagePic;
}

@Generated("org.jsonschema2pojo")
public class Post {
    @SerializedName("post_id")
    @Expose
    public String postId;
    @SerializedName("actor_id")
    @Expose
    public long actorId;
    @SerializedName("picOfPersonWhoPosted")
    @Expose
    public String picOfPersonWhoPosted;
    @SerializedName("nameOfPersonWhoPosted")
    @Expose
    public String nameOfPersonWhoPosted;
    @SerializedName("message")
    @Expose
    public String message;
    @SerializedName("likesCount")
    @Expose
    public long likesCount;
    @SerializedName("comments")
    @Expose
    public List<Object> comments = new ArrayList<Object>();
    @SerializedName("timeOfPost")
    @Expose
    public long timeOfPost;
}

9

ඔබට JSON නූල (jsonString) නියෝජනය කරන ජාවා පන්තියක් (පණිවිඩය කියන්න) තිබේ නම්, ඔබට ජැක්සන් JSON පුස්තකාලය භාවිතා කළ හැකිය :

Message message= new ObjectMapper().readValue(jsonString, Message.class);

පණිවිඩ වස්තුවෙන් ඔබට එහි ඕනෑම ලක්ෂණයක් ලබා ගත හැකිය.


9

Gson ඉගෙන ගැනීමට සහ ක්‍රියාත්මක කිරීමට පහසුය, අප දැනගත යුතු දේ ක්‍රම දෙකක් අනුගමනය කරයි

  • toJson () - ජාවා වස්තුව JSON ආකෘතියට පරිවර්තනය කරන්න

  • fromJson () - JSON ජාවා වස්තුවක් බවට පරිවර්තනය කරන්න

`

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.google.gson.Gson;

public class GsonExample {
    public static void main(String[] args) {

    Gson gson = new Gson();

    try {

        BufferedReader br = new BufferedReader(
            new FileReader("c:\\file.json"));

        //convert the json string back to object
        DataObject obj = gson.fromJson(br, DataObject.class);

        System.out.println(obj);

    } catch (IOException e) {
        e.printStackTrace();
    }

    }
}

`


Gson පිළිබඳ සම්පූර්ණ දැනුමක් සඳහා පහත සබැඳි බලන්න. github.com/google/gson/blob/master/UserGuide.md
venkat

9

JSON අන්තර්ගතය වස්තුවකට විග්‍රහ කිරීමට හෝ JSON අගයන් කියවීමට බොහෝ විවෘත මූලාශ්‍ර පුස්තකාල තිබේ. ඔබේ අවශ්‍යතාවය වන්නේ අගයන් කියවා එය අභිරුචි වස්තුවකට විග්‍රහ කිරීමයි. ඔබගේ නඩුවේදී org.json පුස්තකාලය ප්‍රමාණවත්ය.

එය විග්‍රහ කිරීමට හෝ JsonObject නිර්මාණය කිරීමට org.json පුස්තකාලය භාවිතා කරන්න:

JSONObject jsonObj = new JSONObject(<jsonStr>);

දැන්, ඔබේ අගයන් ලබා ගැනීමට මෙම වස්තුව භාවිතා කරන්න:

String id = jsonObj.getString("pageInfo");

ඔබට සම්පූර්ණ උදාහරණයක් මෙහි දැකිය හැකිය:

JSON ජාවා හි විග්‍රහ කරන්නේ කෙසේද


ඔබගේ සියලු පිළිතුරු වල එම වෙබ් අඩවියට සබැඳියක් ඇති බව පෙනේ. එය අයාචිත තැපැල් නම්, කරුණාකර නවත්වන්න. එය එසේ නොවේ නම්, ව්‍යාකූලත්වයට කණගාටුයි, නමුත් ඔබගේ සියලු පිළිතුරු වල සබැඳියක් පළ කිරීම අවශ්‍ය යැයි මම නොසිතමි.
ඩොනල්ඩ් ඩක්

1
ඔබට සියලු අවස්ථා පැහැදිලි කළ හැකි පිළිතුරක් ලබා දීම දුෂ්කර ය. මෙම අවස්ථාවේ දී මෙන්, json array හෝ බහු json වස්තු කියවන්නේ කෙසේද. මා එසේ කළත්, පිළිතුර ඉතා දිගු වන අතර පුද්ගලයා ව්‍යාකූල විය හැකිය. එබැවින් නිසි උදාහරණයකින් නිසි පැහැදිලි කිරීමක් ලබා දෙන සබැඳියක් මම ලබා දෙමි. ඔහුට සංචාරය කිරීමට තෝරා ගත හැකිය හෝ භාවිතා කළ හැක්කේ මගේ පැහැදිලි කිරීම පමණි.
lalitbhagtani

1
ඔබ සපයා ඇති සබැඳිය පෙන්නුම් කරන්නේ JSON කියවන ආකාරය පමණක් බව මට පෙනේ. JSON කරන්නේ කෙසේද යන්න පිළිබඳ තොරතුරු මට සොයාගත හැක්කේ කොතැනින්ද?
ලැම්ප්‍රොස් ට්සැනෙටෝස්

කණගාටුයි, නමුත් මට ඔබේ ප්‍රශ්නය තේරුණේ නැත: - "JSON කරන්නේ කෙසේද යන්න පිළිබඳව"
lalitbhagtani

7

කරුණාකර මේ වගේ දෙයක් කරන්න:

JSONParser jsonParser = new JSONParser();
JSONObject obj = (JSONObject) jsonParser.parse(contentString);
String product = (String) jsonObject.get("productId");

10
එර්, මෙය කුමන පුස්තකාලයද?
ස්ටුවර්ට්

2
මම හිතන්නේ ඔහු org.json.simple
Lasitha Yapa

7

JSON නූල විග්‍රහ කිරීමට ඔබට Gson පුස්තකාලය භාවිතා කළ හැකිය.

Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(jsonAsString, JsonObject.class);

String pageName = jsonObject.getAsJsonObject("pageInfo").get("pageName").getAsString();
String pagePic = jsonObject.getAsJsonObject("pageInfo").get("pagePic").getAsString();
String postId = jsonObject.getAsJsonArray("posts").get(0).getAsJsonObject().get("post_id").getAsString();

ඔබට "පෝස්ට්" අරාව හරහා ද ලූප කළ හැකිය:

JsonArray posts = jsonObject.getAsJsonArray("posts");
for (JsonElement post : posts) {
  String postId = post.getAsJsonObject().get("post_id").getAsString();
  //do something
}

5
{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    },
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

Java code :

JSONObject obj = new JSONObject(responsejsonobj);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......etc
}

9
කරුණාකර ඔබේ පිළිතුර පැහැදිලි කරන්න කේත පමණක් පිළිතුරු අනෙක් අයට හොඳින් ලේඛනගත කළ කේතයට වඩා බෙහෙවින් අඩුය. බලන්න "; මාළු මිනිසෙකු ඉගැන්වීමට සහ ඔබ ජීවිත කාලය සඳහා ඔහුට කන්න, මිනිසෙක් මාළු දෙන්න ඔබ දිනකට ඔහුට කන්න" .
වයි හ ලී

මෙය 'org.json' lib සඳහා බව සඳහන් කිරීම හොඳය. කෙසේ වෙතත්, මෙය කිසිසේත්ම වාචිකව පැවතීම සඳහා හොඳ ක්‍රමයක් යැයි මම නොසිතමි, සහ 'org.json' ලිබ් යල්පැන ඇති (මන්දගාමී, කරදරකාරී API). වඩා හොඳ තේරීම් තිබේ: භාවිතා කිරීමට GSON, ජැක්සන්, බූන්, ජෙන්සන්.
ස්ටැක්ස්මන්

5

ජාවා හි JSON හි පහත බ්ලොග් සටහන කියවන්න .

මෙම ලිපිය ටිකක් පරණයි, නමුත් තවමත් මට ඔබේ ප්‍රශ්නයට පිළිතුරු දීමට අවශ්‍යයි.

පියවර 1: ඔබේ දත්තවල POJO පන්තියක් සාදන්න.

පියවර 2: දැන් JSON භාවිතයෙන් වස්තුවක් සාදන්න.

Employee employee = null;
ObjectMapper mapper = new ObjectMapper();
try{
    employee =  mapper.readValue(newFile("/home/sumit/employee.json"), Employee.class);
} 
catch (JsonGenerationException e){
    e.printStackTrace();
}

වැඩිදුර විමර්ශනය සඳහා ඔබට පහත සබැඳිය වෙත යොමු විය හැකිය .


4

මෙම පිටුවේ ඉහළ පිළිතුරු එක් දේපලක් සහිත වස්තුව වැනි සරල උදාහරණ භාවිතා කරයි (උදා: නම: අගය}). මම හිතන්නේ තවමත් සරල නමුත් සැබෑ ජීවිත ආදර්ශය කෙනෙකුට උපකාර කළ හැකිය.

ගූගල් පරිවර්තන API විසින් ආපසු ලබා දුන් JSON මෙයයි:

{
  "data": 
     {
        "translations": 
          [
            {
              "translatedText": "Arbeit"
             }
          ]
     }
}

ගූගල් හි Gson භාවිතා කරමින් "පරිවර්තනය කළ ටෙක්ස්ට්" ගුණාංගයේ අගය ලබා ගැනීමට මට අවශ්‍යය.

හැකි ප්‍රවේශයන් දෙකක්:

  1. අවශ්‍ය එක් ලක්ෂණයක් පමණක් ලබා ගන්න

    String json  = callToTranslateApi("work", "de");
    JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
    return jsonObject.get("data").getAsJsonObject()
            .get("translations").getAsJsonArray()
            .get(0).getAsJsonObject()
            .get("translatedText").getAsString();
  2. JSON වෙතින් ජාවා වස්තුව සාදන්න

    class ApiResponse {
        Data data;      
        class Data {
            Translation[] translations;         
            class Translation {
                String translatedText;
            }
         }
     }

    ...

     Gson g = new Gson();
     String json =callToTranslateApi("work", "de");
     ApiResponse response = g.fromJson(json, ApiResponse.class);
     return response.data.translations[0].translatedText;

4

පළමුව ඔබ ක්‍රියාත්මක කිරීමේ පුස්තකාලයක් තෝරා ගත යුතුය .

මෙම JSON සැකසුම් (JSR 353) සඳහා ජාවා API වස්තුව ආකෘතිය සහ streaming ඒපීඅයි භාවිතා විග්රහ කළ කිරීමට ජනනය කිරීම, පරිණාමනය කිරීම හා විමසුම් JSON අතේ ගෙන යා හැකි ඒපීඅයි සපයයි.

මෙම යොමු ක්රියාත්මක කිරීම මෙහි වේ: https://jsonp.java.net/

JSR 353 ක්‍රියාත්මක කිරීමේ ලැයිස්තුවක් මෙහි ඔබට සොයාගත හැකිය :

JSR-353 (JSON) ක්‍රියාත්මක කරන API මොනවාද?

හා ඔබ තීරණය උදව් කිරීමට ... මම මෙන්ම මෙම ලිපිය සොයා ගත්තේ ය:

http://blog.takipi.com/the-ultimate-json-library-json-simple-vs-gson-vs-jackson-vs-json/

ඔබ ජැක්සන් සඳහා ගියහොත්, ජැක්සන් භාවිතා කරමින් JSON අතර / ජාවා සිට පරිවර්තනය කිරීම පිළිබඳ හොඳ ලිපියක් මෙන්න: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json- ජැක්සන් /

එය උපකාරී වේ යැයි සිතමු!


ඔබ යොමු කරන්නේ ජැක්සන් පුස්තකාලයේ 1 වන සංස්කරණයට ය. ජැක්සන් පුස්තකාලයේ වර්තමාන අනුවාදය භාවිතා කිරීමට දැඩි ලෙස යෝජනා කරන්න.
හර්බට් යූ

4

ඔබට ජේවේ ජේසන්පාත් භාවිතා කළ හැකිය . පහත දැක්වෙන්නේ ප්‍රභව කේත, පොම් විස්තර සහ හොඳ ලියකියවිලි සහිත GitHub සබැඳිය.

https://github.com/jayway/JsonPath

කරුණාකර පහත පියවර අනුගමනය කරන්න.

පියවර 1 : මේවන් භාවිතයෙන් ඔබේ පන්ති මාවතේ ජේවේ ජේඑස්එන් මාර්ග පරායත්තතාවය එක් කරන්න හෝ ජාර් ගොනුව බාගත කර එය අතින් එකතු කරන්න.

<dependency>
            <groupId>com.jayway.jsonpath</groupId>
            <artifactId>json-path</artifactId>
            <version>2.2.0</version>
</dependency>

පියවර 2 : කරුණාකර ඔබේ ආදානය JSON මෙම උදාහරණය සඳහා ගොනුවක් ලෙස සුරකින්න. මගේ නඩුවේදී මම ඔබේ JSON සාම්පල් Json.txt ලෙස සුරකිමි. PageInfo සහ පෝස්ට් අතර කොමාවක් ඔබට මග හැරී ඇති බව සලකන්න.

පියවර 3 : බෆර්ඩ් රීඩර් භාවිතයෙන් ඉහත ගොනුවේ JSON අන්තර්ගතය කියවා එය String ලෙස සුරකින්න.

BufferedReader br = new BufferedReader(new FileReader("D:\\sampleJson.txt"));

        StringBuilder sb = new StringBuilder();
        String line = br.readLine();

        while (line != null) {
            sb.append(line);
            sb.append(System.lineSeparator());
            line = br.readLine();
        }
        br.close();
        String jsonInput = sb.toString();

පියවර 4 : ජේවේ JSON විග්‍රහකය භාවිතයෙන් ඔබේ JSON නූල විග්‍රහ කරන්න.

Object document = Configuration.defaultConfiguration().jsonProvider().parse(jsonInput);

පියවර 5 : පහත වැනි විස්තර කියවන්න.

String pageName = JsonPath.read(document, "$.pageInfo.pageName");
String pagePic = JsonPath.read(document, "$.pageInfo.pagePic");
String post_id = JsonPath.read(document, "$.posts[0].post_id");

System.out.println("$.pageInfo.pageName " + pageName);
System.out.println("$.pageInfo.pagePic " + pagePic);
System.out.println("$.posts[0].post_id " + post_id);

ප්‍රතිදානය වනුයේ :

$.pageInfo.pageName = abc
$.pageInfo.pagePic = http://example.com/content.jpg
$.posts[0].post_id  = 123456789012_123456789012

3

මට මේ වගේ JSON තියෙනවා:

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    }
}

ජාවා පන්තිය

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

මෙම JSON ජාවා පන්තියක් බවට පරිවර්තනය කිරීමේ කේතය.

    PageInfo pageInfo = JsonPath.parse(jsonString).read("$.pageInfo", PageInfo.class);

මේවන්

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>2.2.0</version>
</dependency>

2

කෙනෙකුට JSON ලිපිගොනු වල ව්‍යුහය නිරූපණය කරන ජාවා ආකෘති පංති නිර්මාණය කිරීමට සහ JSON ගසෙහි විවිධ අංග වෙත ප්‍රවේශ වීමට Apache odModel annotation භාවිතා කළ හැකිය . වෙනත් විසඳුම් මෙන් නොව මෙය පරාවර්තනයකින් තොරව සම්පූර්ණයෙන්ම ක්‍රියාත්මක වේ ක්‍රියාත්මක වන අතර එමඟින් පරාවර්තනය කළ නොහැකි හෝ සැලකිය යුතු පොදු කාර්යයක් සහිත පරිසරයන්ට සුදුසු වේ.

ඒ නිසා එය නියැදි ලැබෙන කව්ලුවේ ව්යාපෘතිය භාවිතය පෙන්නුම්. පළමුවෙන්ම එය ව්යුහය අර්ථ දක්වයි:

@Model(className="RepositoryInfo", properties = {
    @Property(name = "id", type = int.class),
    @Property(name = "name", type = String.class),
    @Property(name = "owner", type = Owner.class),
    @Property(name = "private", type = boolean.class),
})
final class RepositoryCntrl {
    @Model(className = "Owner", properties = {
        @Property(name = "login", type = String.class)
    })
    static final class OwnerCntrl {
    }
}

ඉන්පසු එය සපයන ලද ආදාන ප්‍රවාහය විග්‍රහ කිරීමට සහ එය සිදු කරන අතරතුර යම් යම් තොරතුරු ලබා ගැනීමට ජනනය කරන ලද නිධිය තොරතුරු සහ හිමිකරු පන්ති භාවිතා කරයි:

List<RepositoryInfo> repositories = new ArrayList<>();
try (InputStream is = initializeStream(args)) {
    Models.parse(CONTEXT, RepositoryInfo.class, is, repositories);
}

System.err.println("there is " + repositories.size() + " repositories");
repositories.stream().filter((repo) -> repo != null).forEach((repo) -> {
    System.err.println("repository " + repo.getName() + 
        " is owned by " + repo.getOwner().getLogin()
    );
})

ඒක තමයි! ඊට අමතරව අසමමුහුර්ත ජාල සන්නිවේදනය සමඟ සමාන උදාහරණයක් පෙන්වන සජීවී සාරාංශයක් මෙහි ඇත.


2

jsoniter(jsoniterator) යනු සාපේක්ෂව නව හා සරල json පුස්තකාලයකි, එය සරල හා වේගවත් ලෙස නිර්මාණය කර ඇත. Json දත්ත අවලංගු කිරීමට ඔබ කළ යුත්තේ එයයි

JsonIterator.deserialize(jsonData, int[].class);

කොහෙද jsonData json දත්ත මාලාවක්.

මෙම පරීක්ෂා නිල වෙබ් අඩවිය වැඩි විස්තර සඳහා.


1

අපට JSON නූලක් JSON වස්තුවක් බවට පරිවර්තනය කිරීමට සහ JSON වස්තුව හරහා නැවත යෙදීමට JSONObject පන්තිය භාවිතා කළ හැකිය. පහත කේතය භාවිතා කරන්න.

JSONObject jObj = new JSONObject(contents.trim());
Iterator<?> keys = jObj.keys();

while( keys.hasNext() ) {
  String key = (String)keys.next();
  if ( jObj.get(key) instanceof JSONObject ) {           
    System.out.println(jObj.getString(String key));
  }
}

2
මෙය android පමණි
Ľubomír

එය ඇන්ඩ්‍රොයිඩ් පමණක් නොවේ: docs.oracle.com/javaee/7/api/javax/json/JsonObject.html
ඩර්මොට් කැනිෆ්

1
ErDermotCanniffe එය ඇන්ඩ්‍රොයිඩ් පමණි.
user4020527

1

සංකීර්ණ json සහ XML ලේඛනය විග්‍රහ කිරීම සඳහා ඔබට DSM ප්‍රවාහ විග්‍රහ කිරීමේ පුස්තකාලය භාවිතා කළ හැකිය . ඩීඑස්එම් දත්ත එක් වරක් පමණක් විග්‍රහ කරන අතර සියලු දත්ත මතකයට පටවන්නේ නැත.

අපි පිටුව ඇති බව කියමුලබා දී ඇති json දත්ත අවලංගු කිරීමට පන්තියක් .

පිටු පන්තිය

public class Page {
    private String pageName;
    private String pageImage;
    private List<Sting> postIds;

    // getter/setter

}

Yaml සිතියම්කරණ ගොනුවක් සාදන්න.

result:
  type: object     # result is array
  path: /posts
  fields:
    pageName:
        path: /pageInfo/pageName
    pageImage:
        path: /pageInfo/pagePic
    postIds:
      path: post_id
      type: array

ක්ෂේත්ර නිස්සාරණය කිරීමට DSM භාවිතා කරන්න.

DSM dsm=new DSMBuilder(new File("path-to-yaml-config.yaml")).create(Page.class);
Page page= (Page)dsm.toObject(new path-to-json-data.json");

පිටු විචල්‍යය json වෙත අනුක්‍රමික කර ඇත:

{
  "pageName" : "abc",
  "pageImage" : "http://example.com/content.jpg",
  "postIds" : [ "123456789012_123456789012" ]
}

සංකීර්ණ json සහ xml සඳහා DSM ඉතා හොඳයි.


0

JsonNodeඔබේ JSON නූලෙහි ව්‍යුහාත්මක ගස් නිරූපණය සඳහා ඔබට භාවිතා කළ හැකිය . එය සර්වබලධාරී පාෂාණ ජැක්සන් පුස්තකාලයේ කොටසකි .

ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.