Databind com Jackson e com Google JSON em Java

Com a febre do "two way databind" do Angularjs o beck-end do Java precisa receber um arquivo ou um objeto JSON e transformar em um objeto Java para a camada de negócio. O objetivo do post é converter um JSON em objeto ou um objeto em JSON fazendo uma leitura ou escrita do arquivo ou do objeto JSON. O nome do processo de conversão de JSON para objeto é na verdade Marshal e o inverso Unmarshal.

Vamos criar no Eclipse um novo Projeto em File>>New>>Other>>Dinamyc Web Project com o nome de JaxonTest.

Next>>Next>> Clica em generate web.xml e fnaliza.

Com o botão direito do mouse sobre o projeto clicar em Configure>>Convert to Maven Project.


Vai ser criado o arquivo pom.xml e vamos adicionar as dependencias dentro da tag <dependecies>.

1. <dependencies>
2.   <dependency>
3.    <groupId>com.fasterxml.jackson.core</groupId>
4.    <artifactId>jackson-annotations</artifactId>
5.    <version>2.6.3</version>
6.   </dependency>
7.   <dependency>
8.    <groupId>com.fasterxml.jackson.core</groupId>
9.    <artifactId>jackson-core</artifactId>
10.    <version>2.6.3</version>
11.   </dependency>
12.   <dependency>
13.    <groupId>com.fasterxml.jackson.core</groupId>
14.    <artifactId>jackson-databind</artifactId>
15.    <version>2.6.3</version>
16.   </dependency>
17.   <dependency>
18.    <groupId>org.codehaus.jackson</groupId>
19.    <artifactId>jackson-mapper-asl</artifactId>
20.    <version>1.9.13</version>
21.   </dependency>
22.  </dependencies>

Agora basta clicar em Maven>>Update Project e as dependências serão baixadas automaticamente e poderão ser visualizadas dentro de Java Rersources>>Libraries>>Maven Dependencies.

Vamos criar tres pacotes agora model, read e write.

Vamos criar em model o arquivo User.java com três variáveis, getters and setters e contrutores:

1. package br.marcelo.model;
2. import java.util.List;
3.  
4.  
5. public class User {
6.  
7.  
8.  private String nome;
9.  private int age;
10.  private List<String> messages;
11.  
12.  public User() {
13.   super();
14.   // TODO Auto-generated constructor stub
15.  }
16.  public User(String nome, int age, List<String> messages) {
17.   super();
18.   this.nome = nome;
19.   this.age = age;
20.   this.messages = messages;
21.  }
22.  public String getNome() {
23.   return nome;
24.  }
25.  public void setNome(String nome) {
26.   this.nome = nome;
27.  }
28.  public int getAge() {
29.   return age;
30.  }
31.  public void setAge(int age) {
32.   this.age = age;
33.  }
34.  public List<String> getMessages() {
35.   return messages;
36.  }
37.  public void setMessages(List<String> messages) {
38.   this.messages = messages;
39.  }
40.   
41. }
42. 
    

Vamos criar o primeiro exemplo em write.

1. package br.marcelo.write;
2.  
3. import java.io.File;
4. import java.io.IOException;
5. import java.util.ArrayList;
6. import java.util.List;
7.  
8. import org.codehaus.jackson.JsonGenerationException;
9. import org.codehaus.jackson.map.JsonMappingException;
10. import org.codehaus.jackson.map.ObjectMapper;
11.  
12. import br.marcelo.model.User;
13.  
14. public class Exemplo1 {
15.  public static void main(String[] args) {
16.  
17.   ObjectMapper mapper = new ObjectMapper();
18.   String curDir;
19.   //For testing
20.   User user = new User();
21.  
22.   user.setNome("Marcelo");
23.   user.setAge(30);
24.  
25.   List<String> messages = new ArrayList<>();
26.   messages.add("mensagem1");
27.   messages.add("mensagem2");
28.   user.setMessages(messages);
29.  
30.   try {
31.    //Get current Directory
32.    curDir = System.getProperty("user.dir");
33.    //Convert object to JSON string and save into file directly
34.    mapper.writeValue(new File(curDir+"\\user.json"), user);
35.    System.out.println("Arquivo localizado em: "+curDir+"\\user.json");
36.    
37.    //Convert object to JSON string
38.    String jsonInString = mapper.writeValueAsString(user);
39.    System.out.println(jsonInString);
40.    
41.    //Convert object to JSON string and pretty print
42.    jsonInString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
43.    System.out.println(jsonInString);
44.    
45.    
46.   } catch (JsonGenerationException e) {
47.    e.printStackTrace();
48.   } catch (JsonMappingException e) {
49.    e.printStackTrace();
50.   } catch (IOException e) {
51.    e.printStackTrace();
52.   }
53.  
54.  }
55.  
56.  
57. }

Neste exemplo utilizamos ObjectMapper() para a criação do arquivo, o objeto user é criado e enviado para o diretório determinado. Segue a saida do console em JSON:


{"nome":"Marcelo","age":30,"messages":["mensagem1","mensagem2"]}
{
  "nome" : "Marcelo",
  "age" : 30,
  "messages" : [ "mensagem1", "mensagem2" ]
}



Agora vamos ler o arquivo criado utilizando o mesmo formato no Exemplo2.java no pacote read.

1. package br.marcelo.read;
2.  
3. import java.io.File;
4. import java.io.IOException;
5.  
6. import com.fasterxml.jackson.core.JsonGenerationException;
7. import com.fasterxml.jackson.databind.JsonMappingException;
8. import com.fasterxml.jackson.databind.ObjectMapper;
9.  
10. import br.marcelo.model.User;
11.  
12. public class Exemplo2 {
13.  
14.  public static void main(String[] args) {
15.   Exemplo2 obj = new Exemplo2();
16.   obj.run();
17.  }
18.  
19.  private void run() {
20.   ObjectMapper mapper = new ObjectMapper();
21.  
22.   String curDir;
23.   try {
24.    //Get current Directory
25.    curDir = System.getProperty("user.dir");
26.    // Convert JSON string from file to Object
27.    User user = mapper.readValue(new File(curDir+"\\user.json"), User.class);
28.    System.out.println(user);
29.  
30.    //Pretty print
31.    String prettyStaff1 = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
32.    System.out.println(prettyStaff1);
33.    
34.    
35.   } catch (JsonGenerationException e) {
36.    e.printStackTrace();
37.   } catch (JsonMappingException e) {
38.    e.printStackTrace();
39.   } catch (IOException e) {
40.    e.printStackTrace();
41.   }
42.  }
43.  
44. }

No Exemplo3 vamos receber o objeto em um objeto do tipo Object() que pode ser qualquer tipo de objeto.

1. package br.marcelo.read;
2.  
3. import java.io.File;
4. import java.io.IOException;
5.  
6. import com.fasterxml.jackson.core.JsonGenerationException;
7. import com.fasterxml.jackson.databind.JsonMappingException;
8. import com.fasterxml.jackson.databind.ObjectMapper;
9.  
10.  
11.  
12. public class Exemplo3 {
13.  
14.  public static void main(String[] args) {
15.   Exemplo3 obj = new Exemplo3();
16.   obj.run();
17.  }
18.  
19.  private void run() {
20.   ObjectMapper mapper = new ObjectMapper();
21.  
22.   String curDir;
23.   try {
24.    // Get current Directory
25.    curDir = System.getProperty("user.dir");
26.    // Convert JSON string from file to Object
27.    Object object = mapper.readValue(new File(curDir + "\\user.json"), Object.class);
28.    System.out.println(object);
29.    
30.    //System.out.println(object.getClass().getName());
31.    
32.    // Pretty print
33.    String prettyStaff1 = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);
34.    System.out.println(prettyStaff1);
35.  
36.   } catch (JsonGenerationException e) {
37.    e.printStackTrace();
38.   } catch (JsonMappingException e) {
39.    e.printStackTrace();
40.   } catch (IOException e) {
41.    e.printStackTrace();
42.   }
43.  }
44.  
45. }

Para o próximo exemplo vamos adicionar ao arquivo pom.xml uma nova dependência:

1. <dependency>
2.    <groupId>com.googlecode.json-simple</groupId>
3.    <artifactId>json-simple</artifactId>
4.    <version>1.1.1</version>
5.   </dependency>

Vamos atualizar novamente o projeto em Maven>>Update Project e a nova dependência poderá ser visualizada nas Libraries.

No Exemplo4.java o objeto é recebido em um objeto do tipo JSONObject.

1. package br.marcelo.read;
2.  
3. import java.io.FileNotFoundException;
4. import java.io.FileReader;
5. import java.io.IOException;
6. import java.util.Iterator;
7. import java.util.List;
8.  
9. import org.json.simple.JSONObject;
10. import org.json.simple.parser.JSONParser;
11. import org.json.simple.parser.ParseException;
12.  
13. public class Exemplo4 {
14.  
15.  public static void main(String[] args) {
16.   JSONObject jsonObject;
17.   //Cria o parse de tratamento
18.   JSONParser parser = new JSONParser();
19.   //Variaveis que irao armazenar os dados do arquivo JSON
20.   String nome;
21.   Long age;
22.   List<String> messages;
23.   String curDir;
24.  
25.   try {
26.    // Get current Directory
27.    curDir = System.getProperty("user.dir");
28.    //Salva no objeto JSONObject o que o parse tratou do arquivo
29.    jsonObject = (JSONObject) parser.parse(new FileReader(
30.      curDir + "\\user.json"));
31.    
32.    /*//Salva nas variaveis os dados retirados do arquivo
33.    name = (String) jsonObject.get("nome");
34.    age = (Long) jsonObject.get("age");
35.    messages = (List<String>) jsonObject.get("messages");*/
36.    
37.     for (Iterator it = jsonObject.keySet().iterator(); it.hasNext();) {  
38.               Object key = it.next();  
39.               Object item = jsonObject.get(key);  
40.               System.out.println(key+":"+item);
41.     }      
42.  
43.    
44.  
45.   }
46.   //Trata as exceptions que podem ser lançadas no decorrer do processo
47.   catch (FileNotFoundException e) {
48.    e.printStackTrace();
49.   } catch (IOException e) {
50.    e.printStackTrace();
51.   } catch (ParseException e) {
52.    // TODO Auto-generated catch block
53.    e.printStackTrace();
54.   }
55.  }
56.  
57. }

Referencias:

http://www.mkyong.com/java/jackson-2-convert-java-object-to-from-json/

http://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

http://stackoverflow.com/questions/18429468/correct-set-of-dependencies-for-using-jackson-mapper