TOC

Um guia para FastJson

Um guia para FastJson

1. Visão geral

FastJson é uma biblioteca Java leve usada para converter strings JSON em objetos Java e vice-versa.

Neste artigo, vamos mergulhar em várias aplicações concretas e práticas da biblioteca FastJson.

2. Configuração do Maven

Para começar a trabalhar com FastJson, primeiro precisamos adicioná-lo ao nossopom.xml: 


    com.alibaba
    fastjson
    1.2.13

E como uma nota rápida -here’s the most updated version da biblioteca no Maven Central.

3. Converter objetos Java para o formato JSON

Vamos definir o seguintePerson Java bean: 

public class Person {

    @JSONField(name = "AGE")
    private int age;

    @JSONField(name = "FULL NAME")
    private String fullName;

    @JSONField(name = "DATE OF BIRTH")
    private Date dateOfBirth;

    public Person(int age, String fullName, Date dateOfBirth) {
        super();
        this.age = age;
        this.fullName= fullName;
        this.dateOfBirth = dateOfBirth;
    }

    // standard getters & setters
}

Podemos usarJSON.toJSONString() para converter um objeto Java em uma String JSON: 

private List listOfPersons = new ArrayList();

@Before
public void setUp() {
    listOfPersons.add(new Person(15, "John Doe", new Date()));
    listOfPersons.add(new Person(20, "Janette Doe", new Date()));
}

@Test
public void whenJavaList_thanConvertToJsonCorrect() {
    String jsonOutput= JSON.toJSONString(listOfPersons);
}

E aqui está o resultado: 

[
    {
        "AGE":15,
        "DATE OF BIRTH":1468962431394,
        "FULL NAME":"John Doe"
    },
    {
        "AGE":20,
        "DATE OF BIRTH":1468962431394,
        "FULL NAME":"Janette Doe"
    }
]

Também podemos ir mais longe e começar a personalizar a saída e controlar coisas comoordering, dataformatting ou sinalizadoresserialization.

Por exemplo - vamos atualizar o bean e adicionar mais alguns campos: 

@JSONField(name="AGE", serialize=false)
private int age;

@JSONField(name="LAST NAME", ordinal = 2)
private String lastName;

@JSONField(name="FIRST NAME", ordinal = 1)
private String firstName;

@JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3)
private Date dateOfBirth;

Aqui está uma lista dos parâmetros mais básicos que podemos usar junto com a anotação@JSONField, a fim de personalizar o processo de conversão:

  • O parâmetroformat é usado para formatar corretamente o atributodate

  • Por padrão, a biblioteca FastJson serializa o Java bean inteiramente, mas podemos usar o parâmetroserialize para ignorar a serialização para campos específicos

  • O parâmetroordinal é usado para especificar a ordem dos campos

E aqui está a nova saída: 

[
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Jhon",
        "DATE OF BIRTH":"19/07/2016"
    },
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Janette",
        "DATE OF BIRTH":"19/07/2016"
    }
]

FastJson também oferece suporte a um recursoBeanToArray serialization muito interessante: 

String jsonOutput= JSON.toJSONString(listOfPersons, SerializerFeature.BeanToArray);

Esta é a aparência da saída neste caso: 

[
    [
        15,
        1469003271063,
        "John Doe"
    ],
    [
        20,
        1469003271063,
        "Janette Doe"
    ]
]

4. Criar objetos JSON

Comoother JSON libraries, criar um objeto JSON do zero é bastante simples, é apenas uma questão de combinar os objetosJSONObjecteJSONArray: 

@Test
public void whenGenerateJson_thanGenerationCorrect() throws ParseException {
    JSONArray jsonArray = new JSONArray();
    for (int i = 0; i < 2; i++) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("AGE", 10);
        jsonObject.put("FULL NAME", "Doe " + i);
        jsonObject.put("DATE OF BIRTH", "2016/12/12 12:12:12");
        jsonArray.add(jsonObject);
    }
    String jsonOutput = jsonArray.toJSONString();
}

E aqui está como o resultado ficará aqui: 

[
   {
      "AGE":"10",
      "DATE OF BIRTH":"2016/12/12 12:12:12",
      "FULL NAME":"Doe 0"
   },
   {
      "AGE":"10",
      "DATE OF BIRTH":"2016/12/12 12:12:12",
      "FULL NAME":"Doe 1"
   }
]

5. Analisar strings JSON em objetos Java

Agora que sabemos como criar um objeto JSON do zero e como converter objetos Java em suas representações JSON, vamos nos concentrar em como analisar uma representação JSON: 

@Test
public void whenJson_thanConvertToObjectCorrect() {
    Person person = new Person(20, "John", "Doe", new Date());
    String jsonObject = JSON.toJSONString(person);
    Person newPerson = JSON.parseObject(jsonObject, Person.class);

    assertEquals(newPerson.getAge(), 0); // if we set serialize to false
    assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());
}

Podemos usarJSON.parseObject() para obter um objeto Java de uma String JSON.

Observe que você deve definir umno-args or default constructor se já tiver declarado seu próprio parâmetro parametrizado, caso contrário, umcom.alibaba.fastjson.JSONException será gerado.

Aqui está o resultado deste teste simples: 

Person [age=20, fullName=John Doe, dateOfBirth=Wed Jul 20 08:51:12 WEST 2016]

Ao usar a opçãodeserialize dentro da anotação@JSONField, podemos ignorar a desserialização para um campo específico, neste caso, o valor padrão será aplicado automaticamente ao campo ignorado: 

@JSONField(name = "DATE OF BIRTH", deserialize=false)
private Date dateOfBirth;

E aqui está o objeto recém-criado: 

Person [age=20, fullName=John Doe, dateOfBirth=null]

6. Configure a conversão JSON usandoContextValueFilter

Em alguns cenários, pode ser necessário termore control sobre o processo de conversão de objetos Java para o formato JSON.

Nesse caso, podemos usar o objetoContextValueFilter para aplicar filtragem adicional e processamento personalizado ao fluxo de conversão: 

@Test
public void givenContextFilter_whenJavaObject_thanJsonCorrect() {
    ContextValueFilter valueFilter = new ContextValueFilter () {
        public Object process(
          BeanContext context, Object object, String name, Object value) {
            if (name.equals("DATE OF BIRTH")) {
                return "NOT TO DISCLOSE";
            }
            if (value.equals("John")) {
                return ((String) value).toUpperCase();
            } else {
                return null;
            }
        }
    };
    String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter);
}

Neste exemplo, ocultamos o campoDATE OF BIRTH, forçando um valor constante, também ignoramos todos os campos que não sãoJohn ouDoe: 

[
    {
        "FULL NAME":"JOHN DOE",
        "DATE OF BIRTH":"NOT TO DISCLOSE"
    }
]

Como você pode ver, este é um exemplo bastante básico, mas é claro que você também pode usar os mesmos conceitos para cenários mais complexos - combinando esse conjunto poderoso e leve de ferramentas oferecidas pela FastJson em um projeto do mundo real.

7. UsandoNameFilter eSerializeConfig

FastJson oferece um conjunto de ferramentas para personalizar suas operações JSON ao lidar com objetos arbitrários - objetos dos quais não temos o código-fonte.

Vamos imaginar que temos uma versão compilada do beanPerson Java, inicialmente declarada neste artigo, e precisamos fazer algumas melhorias na nomenclatura de campos e formatação básica: 

@Test
public void givenSerializeConfig_whenJavaObject_thanJsonCorrect() {
    NameFilter formatName = new NameFilter() {
        public String process(Object object, String name, Object value) {
            return name.toLowerCase().replace(" ", "_");
        }
    };

    SerializeConfig.getGlobalInstance().addFilter(Person.class,  formatName);
    String jsonOutput =
      JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd");
}

Declaramos o filtroformatName usando a classe anônimaNameFilter para processar nomes de campos. O filtro recém-criado é associado à classePerson, e depois adicionado a uma instância global - que é basicamente um atributo estático na classeSerializeConfig.

Agora, podemos converter confortavelmente nosso objeto para o formato JSON, como mostrado anteriormente neste artigo.

Observe que usamostoJSONStringWithDateFormat() em vez detoJSONString() para aplicar rapidamente a mesma regra de formatação em campos de data.

E aqui está o resultado: 

[
    {
        "full_name":"John Doe",
        "date_of_birth":"2016-07-21"
    },
    {
        "full_name":"Janette Doe",
        "date_of_birth":"2016-07-21"
    }
]

Como você pode ver -the fields names got changed, e o valor da data foi formatado corretamente.

CombinarSerializeFilter comContextValueFilter pode fornecer controle total sobre o processo de conversão para objetos Java arbitrários e complexos.

8. Conclusão

Neste artigo, mostramos como usar o FastJson para converter Java beans em strings JSON e como fazer o contrário. Também mostramos como usar alguns doscore features of FastJson para personalizar a saída JSON.

Como você pode ver,the library offers a relatively simple to use but still very powerful API.JSON.toJSONString and JSON.parseObject are all you need to use in order to meet most of your needs – if not all.

Você pode verificar os exemplos fornecidos neste artigo emlinked GitHub project.

Related