values - replace json java




Como analisar o JSON em Java (20)

A - Explicação

Você pode usar as bibliotecas do Jackson , para vincular o JSON String às instâncias do POJO ( Plain Old Java Object ). POJO é simplesmente uma classe com apenas campos privados e métodos getter / setter públicos. Jackson vai percorrer os métodos (usando reflexão ) e mapeia o objeto JSON na instância do POJO à medida que os nomes de campo da classe se ajustam aos nomes de campo do objeto JSON.

No seu objeto JSON, que é na verdade um objeto composto , o objeto principal consiste em dois sub-objetos. Então, nossas classes POJO devem ter a mesma hierarquia. Vou chamar todo o objeto JSON Object as Page . O objeto de página consiste em um objeto PageInfo e uma matriz Post object.

Então temos que criar três classes POJO diferentes;

  • Page Class, uma composição de PageInfo Class e array de Post Instances
  • Classe PageInfo
  • Postagens Classe

O único pacote que usei é o Jackson ObjectMapper, o que fazemos é vincular dados;

com.fasterxml.jackson.databind.ObjectMapper

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

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

Aqui está o código requerido;

B - Main POJO Class: Página

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 - Classe POJO Filho: 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 - Classe infantil 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;
    }

}

Arquivo JSON do E-Sample: sampleJSONFile.json

Acabei de copiar seu exemplo JSON para esse arquivo e colocá-lo na pasta do projeto.

{
   "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 - Demo Code

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 - Saída de demonstração

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

Eu tenho o seguinte texto JSON. Como posso analisá-lo para obter pageName , pagePic , post_id , etc.?

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

  1. Se alguém quiser criar um objeto Java a partir do JSON e vice-versa, use os 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 alguém quiser apenas analisar uma string JSON e obter alguns valores, (ou criar uma string JSON a partir do zero para enviar por fio) use JaveEE jar, que contém JsonReader, JsonArray, JsonObject etc. Você pode baixar a implementação dessa especifique como javax.json. Com esses dois jars, eu posso analisar o json e usar os valores.

    Essas APIs realmente seguem o modelo de análise DOM / SAX do 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");


Além de outras respostas, recomendo este serviço opensource online this para gerar classes Java rapidamente a partir do json ou json schema para GSON, Jackson 1.x ou Jackson 2.x. Por exemplo, se você 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 this para GSON gerou:

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

Os mais notórios são: Jackson, GSON, Genson, FastJson e org.json.

Há tipicamente três coisas que se deve olhar para escolher qualquer biblioteca:

  1. atuação
  2. Facilidade de uso (o código é simples de escrever e legível) - isso combina com recursos.
  3. Para aplicativos para dispositivos móveis: tamanho da dependência / jar

Especificamente para bibliotecas JSON (e quaisquer libs de serialização / desserialização), a ligação de dados também é geralmente de interesse, pois elimina a necessidade de escrever código de placa de caldeira para empacotar / descompactar os dados.

Para 1, veja este benchmark: github.com/fabienrenaud/java-json-benchmark que fiz usando JMH que compara (jackson, gson, genson, fastjson, org.json, jsonp) desempenho de serializadores e desserializadores usando fluxo e APIs de vinculação de dados. Para 2, você pode encontrar vários exemplos na Internet. O benchmark acima também pode ser usado como fonte de exemplos ...

Rápido takeaway do benchmark: Jackson realiza 5 a 6 vezes melhor que org.json e mais que duas vezes melhor que GSON.

Para o seu exemplo em particular, o código a seguir decodifica seu json com 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.
    }
}

Deixe-me saber se você tiver alguma dúvida.


Existem muitas bibliotecas de software livre presentes para analisar o conteúdo JSON em um objeto ou apenas para ler valores JSON. Seu requisito é apenas ler valores e analisá-los para um objeto personalizado. Então, a biblioteca org.json é suficiente no seu caso.

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

JSONObject jsonObj = new JSONObject(<jsonStr>);

Agora, use este objeto para obter seus valores:

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

Você pode ver um exemplo completo aqui:

Como analisar o JSON em Java


O exemplo abaixo mostra como ler o texto na pergunta, representado como a variável "jsonText". Essa solução usa a API javax.json do Java EE7 (que é mencionada em algumas das outras respostas). A razão pela qual eu adicionei isso como uma resposta separada é que o código a seguir mostra como acessar realmente alguns dos valores mostrados na pergunta. Uma implementação da API javax.json seria necessária para fazer esse código ser executado. O pacote completo para cada uma das classes necessárias foi incluído porque 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");

Agora, antes que alguém vá e vote negativamente nessa resposta, porque não usa GSON, org.json, Jackson ou qualquer outra estrutura de terceiros disponível, é um exemplo de "código obrigatório" para a análise do texto fornecido. Estou ciente de que a aderência ao padrão atual JSR 353 não estava sendo considerada para o JDK 9 e, como tal, a especificação JSR 353 deve ser tratada da mesma forma que qualquer outra implementação de manipulação de JSON de terceiros.


Por exemplo, vamos supor que você tenha uma classe Person com apenas um name .

private class Person {
    public String name;

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

Google GSON ( Maven )

Meu favorito pessoal a respeito da grande serialização / desserialização de objetos do 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"}

Atualizar

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

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

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

org.json ( http://mvnrepository.com/artifact/org.json/json )

Se você não precisa da desserialização de objetos, mas para simplesmente obter um atributo, você pode tentar o org.json ( ou veja 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

Se você tem alguma classe Java (digamos Message) representando a string JSON (jsonString), você pode usar a biblioteca Jackson JSON com:

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

e do objeto de mensagem você pode buscar qualquer um dos seus atributos.


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

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

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

Você poderia usar o Google Gson .

Usando essa biblioteca, você só precisa criar um modelo com a mesma estrutura JSON. Em seguida, o modelo é preenchido automaticamente. Você precisa chamar suas variáveis ​​como chaves JSON ou usar @SerializedName se 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 você pode analisar usando a biblioteca Gson:

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

Você pode gerar o modelo a partir do JSON usando automaticamente ferramentas on-line como this .


O analisador quick-json é muito simples, flexível, muito rápido e personalizável. Tente

Características:

  • Compatível com a especificação JSON (RFC4627)
  • Analisador JSON de alto desempenho
  • Suporta abordagem de análise flexível / configurável
  • Validação configurável de pares chave / valor de qualquer Hierarquia JSON
  • Fácil de usar # Muito pequena pegada
  • Eleva o desenvolvedor com facilidade e facilita o rastreamento de exceções
  • Suporte à Validação Customizável Pluggable - Chaves / Valores podem ser validados configurando validadores customizados como e quando encontrados
  • Suporte para validar e não validar o analisador
  • Suporte para dois tipos de configuração (JSON / XML) para uso do analisador quick-JSON
  • Requer JDK 1.5
  • Nenhuma dependência em bibliotecas externas
  • Suporte para Geração JSON por meio da serialização de objetos
  • Suporte para seleção do tipo de coleta durante o processo de análise

Pode ser usado assim:

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

Eu tenho 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 esse JSON em 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>

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

  • toJson () - Converte o objeto Java para o formato JSON

  • fromJson () - Converte JSON em objeto 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();
    }

    }
}

`


Por favor, faça algo assim:

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

As principais respostas nesta página usam exemplos muito simples, como o objeto com uma propriedade (por exemplo, {nome: valor}). Eu acho que esse exemplo simples, mas real, pode ajudar alguém.

Então, este é o JSON retornado pela API do Google Tradutor:

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

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

Duas abordagens possíveis:

  1. Recupere 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. Crie um objeto Java a partir 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;

Pode-se usar a anotação Apache @Model para criar classes de modelo Java representando a estrutura de arquivos JSON e usá-las para acessar vários elementos na árvore JSON . Ao contrário de outras soluções, esta funciona completamente sem reflexão e, portanto, é adequada para ambientes onde a reflexão é impossível ou vem com sobrecarga significativa.

Há um exemplo de projeto Maven mostrando o uso. Primeiro de tudo 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, em seguida, ele usa as classes RepositoryInfo e Owner geradas para analisar o fluxo de entrada fornecido e selecionar determinadas 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()
    );
})

É isso! Além disso, aqui está uma essência ao vivo mostrando um exemplo semelhante junto com a comunicação de rede assíncrona.


Podemos usar a classe JSONObject para converter uma string JSON em um objeto JSON e para iterar sobre o objeto 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));
  }
}

Você pode usar JsonNodepara uma representação em árvore estruturada de sua string JSON. É parte da JacksonJackson sólida, que é onipresente.

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

Você pode usar o Jayway JsonPath . Abaixo está um link do GitHub com código-fonte, detalhes de pom e boa documentação.

https://github.com/jayway/JsonPath

Por favor, siga os passos abaixo.

Etapa 1 : Inclua a dependência do caminho jayway JSON em seu caminho de classe usando o Maven ou faça o download do arquivo JAR e inclua-o manualmente.

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

Etapa 2 : salve seu JSON de entrada como um arquivo para este exemplo. No meu caso, salvei seu JSON como sampleJson.txt. Note que você perdeu uma vírgula entre pageInfo e posts.

Etapa 3 : leia o conteúdo JSON do arquivo acima usando bufferedReader e salve-o como 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();

Etapa 4 : Analise sua string JSON usando o analisador jayway JSON.

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

Passo 5 : leia os detalhes como abaixo.

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






parsing