The org.a biblioteca json é fácil de usar. Código de exemplo abaixo:

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");
    ......
}

Poderá encontrar mais exemplos em: Parse JSON em Java

Frasco para download: http://mvnrepository.com/artifact/org.json/json

Para o bem do exemplo vamos assumir que você tem uma classe Person com apenas um name.

private class Person {
    public String name;

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

Google GSON (Maven)

O meu favorito quanto à grande serialização JSON / de-serialização de objectos.

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"}

Actualizar

Se quiser obter um único atributo, pode fazê-lo facilmente com a biblioteca Google também:

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

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

Org.JSON (Maven)

Se não precisa de Des-serialização de objetos, mas para simplesmente obter um atributo, você pode tentar org.json (ou olhe o exemplo Gson acima!)

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

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

Jackson (Maven)

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

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

1. Se alguém quiser criar objecto Java a partir de JSON e vice-versa, use frascos de terceiros GSON ou JACKSON, etc.

   //from object to JSON 
   Gson gson = new Gson();
   gson.toJson(yourObject);
   
   // from JSON to object 
   yourObject o = gson.fromJson(JSONString,yourObject.class);
   

2. Mas se apenas se quiser processar uma cadeia de caracteres JSON e obter alguns valores, (ou criar uma cadeia de caracteres JSON do zero para enviar um fio) basta usar o jar JaveEE que contém JsonReader, JsonArray, JsonObject etc. Você pode querer baixar a implementação dessa especificação como javax.json. Com estes dois frascos eu sou capaz de analisar o json e usar os valores.

   Estas APIs seguem o modelo de análise DOM/SAX de XML.

   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 parser é muito simples, flexível, muito rápido e personalizável. Tenta.

Características:

• em conformidade com a especificação JSON (RFC4627)
• json parser de alto desempenho
• suporta uma abordagem de processamento flexível / configurável
• validação configurável de pares de chaves / valores de qualquer hierarquia JSON
• Fácil de usar # pegada muito pequena
• aumenta o desenvolvimento amigável e fácil de rastrear excepções
• as chaves / valores de validação personalizadas que podem ser plugados poderão ser validados configurando os validadores personalizados à medida que forem encontrados
• Validação e não Validação do suporte do analisador
• Suporte para dois tipos de configuração (JSON / XML) para usar a validação rápida do analisador
• necessita de JDK 1, 5
• sem dependência de bibliotecas externas
• Suporte para a geração JSON através da serialização de objectos
• Suporte para selecção do tipo de colecção durante processo de análise

Pode ser usado assim:

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

É uma especificação e as boas pessoas do JayWay criaram uma implementação Java para a especificação que você pode encontrar aqui: https://github.com/jayway/JsonPath

Então basicamente para usá-lo, adicione-o ao seu projeto, por exemplo:

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

E para utilizar:

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...

Verifique a página de especificação JsonPath para mais informações sobre as outras formas de transversal JSON.

A - Explicação

Podes usar as bibliotecasdo Jackson para ligar o fio JSON ao POJO (objecto Java Antigo simples) instâncias. POJO é simplesmente uma classe com apenas campos privados e métodos públicos de getter / setter. Jackson vai atravessar os métodos (usando reflexão ), e mapeia o objeto JSON na instância de POJO como os nomes de campo da classe Se encaixa aos nomes de campo do objeto JSON.

No teu JSON object, which is actually a composite object, the main object consists o two sub-objects. Então, nossas classes de POJO devem ter a mesma hierarquia. Vou chamar o objecto JSON como objecto da Página. O objecto consiste num objectoO Paginfo , e uma lista de objectos .

• Page Class, a composite of PageInfo Class and array of Post Instâncias
• PageInfo Classe
• Lugares Classe

com.fasterxml.jackson.databind.ObjectMapper

As dependências necessárias, os ficheiros jar estão listados abaixo;

• jackson-core-2.5.1.frasco
• jackson-databind-2.5.1.frasco
• jackson-annotations-2.5.0.frasco

Aqui está o código necessário;

B-Main POJO Classe: Page

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-Child Pojo Class : Paginfo

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-Child Classe POJO: Post

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-Sample JSON File: sampleJSONFile.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"
         }
    ]
}

Código De Demonstração

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-Demo Saída

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

Pode utilizar O Google Gson .

Usando esta biblioteca só precisa de criar um modelo com a mesma estrutura JSON. Então o modelo é automaticamente preenchido. Você tem que chamar suas variáveis como suas chaves JSON, ou usar @SerializedName se você quiser usar nomes diferentes.

Por exemplo:

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"
        }
    ]
}

Modelo:

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;
}

Agora pode processar usando a biblioteca Gson:

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

Você pode gerar o modelo a partir do JSON usando automaticamente o 'online' ferramentas como isto .

Utilizar minimal-json que é muito rápido e fácil de usar. Você pode analisar a partir de fio obj e Stream.

Dados da amostra:

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

Análise:

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

A criar o JSON:

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

Maven:

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

O exemplo abaixo mostra como ler o texto na pergunta, representado como a variável "jsonText". Esta solução usa o Java EE7 javax.JSON API (que é mencionado em algumas das outras respostas). A razão pela qual eu adicionei isso como uma resposta separada é que o seguinte código mostra como realmente acessar alguns dos valores mostrados na pergunta. Uma implementação do javax.json API seria necessário para fazer este código correr. O pacote completo para cada das classes necessárias foi incluído como eu não queria declarar declarações de "importação".

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");

JSONArray rootOfPage =  new JSONArray(JSONString);

Já que ninguém mencionou isso ainda, aqui está o início de uma solução usando Nashorn (JavaScript runtime part of Java 8).

Solução

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));
}

Comparação de Desempenho

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

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

Org.JSON demora 20 ~ 21 segundos

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

O Jackson demora 6,5 ~ 7 segundos.

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

Se tiver alguma classe Java (dizer mensagem) que represente o texto JSON( jsonString), poderá usar Jackson JSON library com:

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

E a partir do objecto da mensagem poderá obter qualquer um dos seus atributos.

Para além de outras respostas, recomendo este serviço on-line opensource jsonschema2pojo.org para gerar rapidamente classes Java a partir de json ou JSON schema para GSON, Jackson 1.x ou Jackson 2.X. por exemplo, se tiver:

{
   "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
         }
    ]
}

O jsonschema2pojo.org para o GSON gerado:

@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;
}

Existem muitas bibliotecas JSON disponíveis em Java.

1. desempenho
Facilidade de utilização (o código é simples de escrever e legível) - isso combina com as características.
2. para aplicações móveis: dependências/Tamanho do frasco

Especificamente para bibliotecas JSON (e qualquer serialização/deserialização libs), a databinding também é geralmente de interesse, uma vez que remove a necessidade de escrever código de placa de caldeira para embalar/descompactar os dados.

Para 1, ver este parâmetro de referência: https://github.com/fabienrenaud/java-json-benchmark eu usei JMH que se compara (jackson, gson, genson, fastjson, org.JSON, jsonp) performance of serializers and deserializers using stream and databind APIs. Para 2, você pode encontrar inúmeros exemplos na Internet. A referência acima pode também ser utilizada como fonte de exemplo...

Uma rápida tomada do benchmark: O Jackson executa 5 a 6 vezes melhor do que o org.json e mais do dobro do que GSON.

Para o seu exemplo em particular, o seguinte código descodifica o seu json com o jackson:

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.
    }
}

O Gson é fácil de aprender e implementar, o que precisamos saber é seguir dois métodos

• toJson() – converter o objecto Java para o formato JSON

• dejson() – converter o JSON num objecto 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();
    }

    }
}

`

Existem muitas bibliotecas de código aberto Presentes para processar o conteúdo de JSON para um objeto ou apenas para ler os valores de JSON. Sua exigência é apenas ler os valores e analisá-lo para objeto personalizado. Então, org.a biblioteca json é suficiente no seu caso.

Utilize org.biblioteca json para analisá-la e criar JsonObject:

JSONObject jsonObj = new JSONObject(<jsonStr>);

Agora, use este objecto para obter os seus valores:

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

Você pode ver um exemplo completo aqui:

Como processar JSON em Java

Pode usar a Biblioteca Gson para analisar o texto 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();

Você também pode circular através do array "posts" como assim:

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

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

{
   "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
}

As respostas de topo nesta página usam exemplos muito simples como objecto com uma propriedade (por exemplo {nome: valor}). Acho que o exemplo da vida real pode ajudar alguém.

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

Quero recuperar o valor do atributo" translatedText", por exemplo," Arbeit", usando o Gson do Google.

Duas abordagens possíveis:

1. Obter apenas um atributo necessário

   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. Criar Java objecto do 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;
   

Primeiro você precisa selecionar uma biblioteca de implementação para fazer isso.

A API Java para o processamento JSON (JSR 353) fornece APIs portáteis para processar, gerar, transformar e consultar JSON usando o modelo object e as APIs streaming.

A implementação de referência está aqui: https://jsonp.java.net/

Aqui você pode encontrar uma lista de implementações de Jsr 353:

Quais são as API que implementam a JSR-353 (JSON)

E para te ajudar a decidir... Também encontrei este artigo:

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

Se você ir para Jackson, aqui está um bom artigo sobre a conversão entre JSON para/de Java utilizando Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

Leia o seguinte post no blog, JSON in Java .

Passo 1: Criar uma classe de POJO dos seus dados.

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

Para mais referências, pode referir-se ao seguinte link.

Pode utilizar Jayway JsonPath . Abaixo está um link GitHub com código fonte, detalhes pom e boa documentação.

Https://github.com/jayway/JsonPath

Por favor, siga os passos abaixo.

Passo 1 : Adicione a dependência da localização do jayway JSON na sua localização da classe, usando o Maven ou obtendo o ficheiro JAR e adicionando-o manualmente.

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

Passo 2 : por favor, guarde o seu JSON de entrada como um ficheiro para este exemplo. No meu caso, salvei o teu JSON como sampleJson.txt. Note que você perdeu uma vírgula entre o paginfo e os posts.

Passo 3 : Leia o conteúdo do JSON do ficheiro acima usando o 'buffer' e grave-o como texto.

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();

Passo 4 : analise o seu texto JSON usando o analisador jayway JSON.

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

Passo 5 : Leia os detalhes como em baixo.

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);

A saída será:

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

Tenho o JSON assim.:

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

Classe Java

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

Código para converter este JSON para uma classe Java.

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

Maven

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

Pode-se usar Apache @Model annotation para criar Java classes de modelos que representam a estrutura dos ficheiros JSON e usá-los para aceder a vários elementos na árvore JSON. Ao contrário de outras soluções Este Funciona completamente sem reflexão e é, portanto, adequado para ambientes onde a reflexão é impossível ou vem com sobrecarga significativa.

Existe um projecto maven de amostra que mostra a utilização. Em primeiro lugar, define a estrutura:

@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 {
    }
}

E então ele usa as classes RepositoryInfo e proprietário gerados para processar o fluxo de entrada fornecido e pegar certas informações ao fazer isso:

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()
    );
})

Pode usar JsonNode para uma representação em árvore estruturada da sua cadeia de caracteres JSON. Faz parte da rocha sólida. a biblioteca jackson, que é omnipresente.

ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");

Podemos usar a classe JSONObject para converter uma cadeia de JSON para um objecto JSON, e para iterar sobre o objecto JSON. Use o seguinte código.

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));
  }
}

Primeiro de tudo isto não é um dado JSON válido

Você tem que colocar vírgula entre dois dados json "paginfo" e "posts".

Os dados JSON válidos são os seguintes

{
   "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"
         }
    ]
}

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.5</version>
</dependency>

Você deve dar uma tentativa no código abaixo, isso iria funcionar:

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

Class JsonNodeExtractor{

public void convertToJson(){


String filepath = "c:\\data.json";
ObjectMapper mapper = new ObjectMapper();
JsonNode node =  mapper.readTree(filepath);

// create a JsonNode for every root or subroot element in the Json String
JsonNode pageInfoRoot = node.path("pageInfo");

// Fetching elements under 'pageInfo'
String pageName =  pageInfoRoot.path("pageName").asText();
String pagePic = pageInfoRoot.path("pagePic").asText();

// Now fetching elements under posts
JsonNode  postsNode = node.path("posts");
String post_id = postsNode .path("post_id").asText();
String nameOfPersonWhoPosted = postsNode 
.path("nameOfPersonWhoPosted").asText();

}
}