Java에서 JSON을 구문 분석하는 방법
다음 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"
}
]
}
org.json의 라이브러리를 사용하기 쉽습니다. 아래 예제 코드 :
import org.json.*;
JSONObject obj = new JSONObject(" .... ");
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");
......
}
더 많은 예제를 찾을 수 있습니다 : Parse JSON in Java
다운로드 가능한 jar : http://mvnrepository.com/artifact/org.json/json
예를 위해서이 클래스가 있다고 가정 할 수 있습니다 Person단지와를 name.
private class Person {
public String name;
public Person(String name) {
this.name = name;
}
}
Google GSON ( Maven )
객체의 훌륭한 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"}
최신 정보
단일 속성을 얻으려면 Google 라이브러리에서도 쉽게 수행 할 수 있습니다.
JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject();
System.out.println(jsonObject.get("name").getAsString()); //John
Org.JSON ( Maven )
객체 역 직렬화가 필요하지 않지만 단순히 속성을 얻기 위해 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
JSON에서 Java 개체를 만들고 그 반대의 경우에는 GSON 또는 JACKSON 타사 jar 등을 사용하십시오.
//from object to JSON Gson gson = new Gson(); gson.toJson(yourObject); // from JSON to object yourObject o = gson.fromJson(JSONString,yourObject.class);그러나 JSON 문자열을 구문 분석하고 일부 값을 얻으려면 (또는 유선으로 보내기 위해 처음부터 JSON 문자열을 생성) JsonReader, JsonArray, JsonObject 등이 포함 된 JaveEE jar를 사용하십시오. 그 구현을 다운로드 할 수 있습니다. javax.json과 같은 사양. 이 두 항아리로 json을 구문 분석하고 값을 사용할 수 있습니다.
이러한 API는 실제로 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");
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);
A-설명
JSON String을 POJO ( Plain Old Java Object ) 인스턴스 에 바인딩 하기 위해 Jackson 라이브러리 를 사용할 수 있습니다 . POJO는 단순히 private 필드와 public getter / setter 메서드 만있는 클래스입니다. Jackson은 리플렉션을 사용하여 메서드를 탐색하고 클래스의 필드 이름이 JSON 개체의 필드 이름에 맞기 때문에 JSON 개체를 POJO 인스턴스에 매핑합니다.
실제로 복합 객체 인 JSON 객체 에서 기본 객체는 두 개의 하위 객체로 구성됩니다. 따라서 POJO 클래스는 동일한 계층 구조를 가져야합니다. 전체 JSON 개체를 페이지 개체로 부르겠습니다 . 페이지 개체는 PageInfo 개체와 Post 개체 배열로 구성됩니다.
따라서 세 가지 다른 POJO 클래스를 만들어야합니다.
- PageInfo 클래스와 포스트 인스턴스 배열의 합성물 인 페이지 클래스
- PageInfo 클래스
- 게시물 클래스
제가 사용한 유일한 패키지는 Jackson ObjectMapper입니다. 우리가하는 일은 데이터를 바인딩하는 것입니다.
com.fasterxml.jackson.databind.ObjectMapper
필요한 종속성, jar 파일은 다음과 같습니다.
- jackson-core-2.5.1.jar
- jackson-databind-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;
}
}
C-자식 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;
}
}
D-아동 POJO 클래스 : 포스트
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;
}
}
E-샘플 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"
}
]
}
F-데모 코드
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());
}
}
G-데모 출력
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
제공된 거의 모든 답변에는 관심있는 속성의 값에 액세스하기 전에 JSON을 Java 개체로 완전히 역 직렬화해야합니다. 이 경로로 이동하지 않는 또 다른 대안 은 JSON 용 XPath와 같은 JsonPATH 를 사용 하고 JSON 개체의 순회를 허용하는 것입니다.
이것은 사양이며 JayWay의 좋은 사람들은 여기에서 찾을 수있는 사양에 대한 Java 구현을 만들었습니다 : 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");
기타...
JSON을 가로 지르는 다른 방법에 대한 자세한 내용은 JsonPath 사양 페이지를 확인하세요.
Google Gson을 사용할 수 있습니다 .
이 라이브러리를 사용하면 동일한 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);
JSON은 자동으로 같은 온라인 도구를 사용하는 당신은 모델을 생성 할 수 있습니다 이 .
사용 을 최소화-JSON 매우 빠르고 사용하기 쉽습니다. 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>
가장 좋은 방법 은 아직 진행중인 공식 Java JSON API 를 사용 하는 것입니다.
아래 예는 "jsonText"변수로 표시된 질문의 텍스트를 읽는 방법을 보여줍니다. 이 솔루션은 Java EE7 javax.json API를 사용합니다 (다른 답변에서 언급 됨). 별도의 답변으로 추가 한 이유는 다음 코드 가 질문에 표시된 일부 값 에 실제로 액세스 하는 방법을 보여주기 때문 입니다. javax.json의 API의 구현은 이 코드를 실행할 수 있도록해야 할 것이다. "import"문을 선언하고 싶지 않았기 때문에 필요한 각 클래스에 대한 전체 패키지가 포함되었습니다.
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, Jackson 또는 사용 가능한 다른 제 3 자 프레임 워크를 사용하지 않기 때문에 누군가가이 답변에 반대표를 던지기 전에 제공된 텍스트를 구문 분석하는 질문에 대한 "필수 코드"의 예입니다. 나는 것을 잘 알고 현재의 표준 JSR 353 준수가 JDK 9 고려되지 않는 한 과 등으로 JSR 353 스펙 구현을 처리 다른 3 자 JSON과 동일하게 취급되어야한다.
아직 아무도 언급하지 않았기 때문에 Nashorn (Java 8의 JavaScript 런타임 부분이지만 Java 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));
}
성능 비교
저는 각각 20, 20, 100 요소의 세 배열을 포함하는 JSON 콘텐츠를 작성했습니다. 세 번째 배열에서 100 개의 요소 만 가져오고 싶습니다. 다음 JavaScript 함수를 사용하여 항목을 구문 분석하고 가져옵니다.
var fun = function(raw) {JSON.parse(raw).entries};
Nashorn을 사용하여 백만 번 호출을 실행하는 데 7.5 ~ 7.8 초가 걸립니다.
(JSObject) invocable.invokeFunction("fun", json);
org.json 은 20 ~ 21 초 소요
new JSONObject(JSON).getJSONArray("entries");
Jackson 은 6.5 ~ 7 초 걸립니다
mapper.readValue(JSON, Entries.class).getEntries();
이 경우 Jackson은 org.json보다 성능이 훨씬 우수한 Nashorn보다 성능이 뛰어납니다. Nashorn API는 org.json 또는 Jackson보다 사용하기가 더 어렵습니다. 요구 사항에 따라 Jackson과 Nashorn은 모두 실행 가능한 솔루션이 될 수 있습니다.
이것은 얼마나 쉬운 일인지 내 마음을 사로 잡았습니다. String기본 org.json 패키지의 JSONObject 생성자에 JSON 보유를 전달할 수 있습니다 .
JSONArray rootOfPage = new JSONArray(JSONString);
끝난. 마이크를 떨어 뜨 립니다. 이것도 함께 작동 JSONObjects합니다. 그 후에는 객체 Objects에서 get()메서드를 사용하는 계층 구조를 살펴볼 수 있습니다.
Java에서 사용할 수있는 많은 JSON 라이브러리가 있습니다.
가장 악명 높은 것은 Jackson, GSON, Genson, FastJson 및 org.json입니다.
일반적으로 라이브러리를 선택하기 위해 살펴보아야 할 세 가지 사항이 있습니다.
- 공연
- 사용 편의성 (코드는 작성하기 쉽고 읽기 쉬움)-기능과 함께 제공됩니다.
- 모바일 앱의 경우 : 종속성 / jar 크기
특히 JSON 라이브러리 (및 모든 직렬화 / 역 직렬화 라이브러리)의 경우 데이터 바인딩은 데이터를 압축 / 압축 해제하기 위해 상용구 코드를 작성할 필요가 없기 때문에 일반적으로 중요합니다.
: 1의 경우,이 벤치 마크를 참조 https://github.com/fabienrenaud/java-json-benchmark 내가 사용 않았다 JMH 비교 (잭슨, GSON, genson, fastjson, org.json, JSONP) 스트림을 사용하여 시리얼 라이저 및 디시리얼라이저의 성능을 및 데이터 바인딩 API. 2의 경우 인터넷에서 수많은 예제를 찾을 수 있습니다. 위의 벤치 마크는 예제 소스로도 사용할 수 있습니다.
벤치 마크 요약 : Jackson의 성능은 org.json보다 5 ~ 6 배, GSON보다 2 배 이상 우수합니다.
특정 예의 경우 다음 코드는 jackson으로 json을 디코딩합니다.
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.
}
}
궁금한 점이 있으면 알려주세요.
다른 답변 외에도 GSON, Jackson 1.x 또는 Jackson 2.x 용 json 또는 json 스키마에서 Java 클래스를 빠르게 생성하기 위해이 온라인 오픈 소스 서비스 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;
}
JSON 문자열 (jsonString)을 나타내는 Java 클래스 (예 : Message)가있는 경우 다음 과 함께 Jackson JSON 라이브러리를 사용할 수 있습니다 .
Message message= new ObjectMapper().readValue(jsonString, Message.class);
그리고 메시지 개체에서 속성을 가져올 수 있습니다.
JSON 콘텐츠를 객체로 구문 분석하거나 JSON 값을 읽기위한 많은 오픈 소스 라이브러리가 있습니다. 귀하의 요구 사항은 값을 읽고이를 사용자 지정 개체로 구문 분석하는 것입니다. 따라서 org.json 라이브러리는 귀하의 경우 충분합니다.
org.json 라이브러리를 사용하여 구문 분석하고 JsonObject를 만듭니다.
JSONObject jsonObj = new JSONObject(<jsonStr>);
이제이 개체를 사용하여 값을 가져옵니다.
String id = jsonObj.getString("pageInfo");
여기에서 완전한 예를 볼 수 있습니다.
Gson 은 배우고 구현하기 쉽습니다. 우리가 알아야 할 것은 두 가지 방법을 따르는 것입니다.
toJson () – Java 객체를 JSON 형식으로 변환
fromJson () – JSON을 Java 객체로 변환
`
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();
}
}
}
`
다음과 같이하십시오.
JSONParser jsonParser = new JSONParser();
JSONObject obj = (JSONObject) jsonParser.parse(contentString);
String product = (String) jsonObject.get("productId");
Gson 라이브러리를 사용하여 JSON 문자열을 구문 분석 할 수 있습니다.
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();
다음과 같이 "posts"배열을 반복 할 수도 있습니다.
JsonArray posts = jsonObject.getAsJsonArray("posts");
for (JsonElement post : posts) {
String postId = post.getAsJsonObject().get("post_id").getAsString();
//do something
}
다음 블로그 게시물 인 JSON in Java를 읽어보십시오 .
이 게시물은 조금 오래되었지만 여전히 질문에 대답하고 싶습니다.
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();
}
자세한 내용은 다음 링크를 참조하십시오 .
{
"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
}
이 페이지의 상위 답변은 하나의 속성 (예 : {name : value})이있는 개체와 같은 너무 간단한 예를 사용합니다. 여전히 간단하지만 실제 사례가 누군가를 도울 수 있다고 생각합니다.
따라서 이것은 Google Translate API에서 반환 한 JSON입니다.
{
"data":
{
"translations":
[
{
"translatedText": "Arbeit"
}
]
}
}
Google의 Gson을 사용하여 "translatedText"속성 (예 : "Arbeit")의 값을 검색하고 싶습니다.
두 가지 가능한 접근 방식 :
필요한 속성 하나만 검색
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();JSON에서 Java 개체 만들기
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;
먼저이를 위해 구현 라이브러리 를 선택 해야합니다.
JSON 처리 (JSR 353) 용 자바 API는 변환 생성 파싱하는 휴대용 API를 제공하고, 질의 JSON 객체 모델을 이용하여 API를 스트리밍.
참조 구현은 여기에 있습니다 : 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/
Jackson을 찾으면 Jackson을 사용하여 JSON과 Java 간의 변환에 대한 좋은 기사가 있습니다. https://www.mkyong.com/java/how-to-convert-java-object-to-from-json- 잭슨 /
도움이 되었기를 바랍니다.
Jayway JsonPath 를 사용할 수 있습니다 . 아래는 소스 코드, pom 세부 정보 및 좋은 문서가있는 GitHub 링크입니다.
https://github.com/jayway/JsonPath
아래 단계를 따르십시오.
1 단계 : Maven을 사용하여 클래스 경로에 jayway JSON 경로 종속성을 추가하거나 JAR 파일을 다운로드하고 수동으로 추가합니다.
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
<version>2.2.0</version>
</dependency>
2 단계 :이 예제에서는 입력 JSON을 파일로 저장하십시오. 제 경우에는 JSON을 sampleJson.txt로 저장했습니다. pageInfo와 게시물 사이에 쉼표가 누락되었습니다.
3 단계 : bufferedReader를 사용하여 위 파일에서 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 단계 : jayway 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
다음과 같은 JSON이 있습니다.
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
}
자바 클래스
class PageInfo {
private String pageName;
private String pagePic;
// Getters and setters
}
이 JSON을 Java 클래스로 변환하기위한 코드입니다.
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>
jsoniter(jsoniterator)는 간단하고 빠르도록 설계된 비교적 새롭고 간단한 json 라이브러리입니다. json 데이터를 역 직렬화하기 위해해야 할 일은
JsonIterator.deserialize(jsonData, int[].class);
jsonDatajson 데이터의 문자열은 어디에 있습니까 ?
자세한 내용 은 공식 웹 사이트 를 확인하세요.
하나는 사용할 수 아파치 @Model 주석을 작성하는 자바 의 구조를 나타내는 모델 클래스 JSON의 파일과 다양한 요소에 액세스하는 데 사용할 JSON의 나무. 다른 솔루션과 달리 이것은 반사없이 완전히 작동 하므로 반사가 불가능하거나 상당한 오버 헤드가 발생하는 환경에 적합합니다.
이 샘플 Maven 프로젝트 사용을 보여주는이. 우선 구조를 정의합니다.
@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 {
}
}
그런 다음 생성 된 RepositoryInfo 및 Owner 클래스를 사용하여 제공된 입력 스트림을 구문 분석하고이를 수행하는 동안 특정 정보를 선택합니다.
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()
);
})
그게 다야! 여기 에 비동기 네트워크 통신과 함께 유사한 예를 보여주는 라이브 요점이 있습니다.
JSONObject 클래스를 사용하여 JSON 문자열을 JSON 객체로 변환하고 JSON 객체를 반복 할 수 있습니다. 다음 코드를 사용하십시오.
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));
}
}
복잡한 json 및 XML 문서를 구문 분석 하기 위해 DSM 스트림 구문 분석 라이브러리를 사용할 수 있습니다 . DSM은 데이터를 한 번만 구문 분석하고 모든 데이터를 메모리에로드하지 않습니다.
주어진 json 데이터를 역 직렬화하는 Page 클래스 가 있다고 가정 해 보겠습니다 .
페이지 클래스
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" ]
}
DSM is very good for complex json and xml.
You can use JsonNode for a structured tree representation of your JSON string. It's part of the rock solid jackson library which is omnipresent.
ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");
참고URL : https://stackoverflow.com/questions/2591098/how-to-parse-json-in-java
'Programing' 카테고리의 다른 글
| % ~ dp0은 무엇을 의미하며 어떻게 작동합니까? (0) | 2020.09.28 |
|---|---|
| What does in XML mean? (0) | 2020.09.28 |
| Rails 정품 토큰 이해 (0) | 2020.09.28 |
| 데이터 속성으로 요소 선택 (0) | 2020.09.28 |
| 로컬 저장소와 쿠키 (0) | 2020.09.28 |