Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Dica: Depois que o artigo for escrito, o índice poderá ser gerado automaticamente. Para saber como gerá-lo, consulte o documento de ajuda à direita.

---

Uma dúvida: Os atributos que começam com isXXX na classe de entidade back-end são removidos automaticamente após serem passados ​​para o front-end.

Solução:

1. Altere o nome do método isReceipt() gerado para getIsReceipt()
2. Adicione a anotação @JsonProperty(value = “isXXX”) ao método get gerado, ou seja, isReceipt.

 @JsonProperty(value = "isReceipt")
    public boolean isReceipt() {
        return isReceipt;
    }
    @JsonProperty(value = "isExamine")
    public boolean isExamine() {
        return isExamine;
    }

1
2
3
4
5
6
7
8
9

@JsonProperty e @JSONField

1. Introdução

• As anotações @JsonProperty e @JSONField são paraAo converter obj em string json, substitua o nome do atributo do java bean pelo nome do atributo de destino . É comum em cenários onde os nomes das propriedades são inconsistentes ao chamar interfaces de terceiros.
• As funções das duas anotações são as mesmas, mas vêm de fontes diferentes e são usadas de maneiras diferentes. As semelhanças e diferenças serão explicadas em detalhes a seguir!

2. A diferença entre anotações

2.1 A estrutura subjacente é diferente

• @JsonProperty é implementado por Jackson

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>版本号</version>
</dependency>
1
2
3
4
5

• @JSONField é implementado por fastjson

         <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>版本号</version>
        </dependency>

1
2
3
4
5
6

2.2 Diferentes escopos

A anotação @JSONproperty é usada paraAtributosacima

• Para serializar o atributo trueName para nome, você pode adicionar @JsonProperty(value="name") ao nome do atributo.

A anotação @JSONField pode ser usadaobter, definir e propriedadesacima

• Para serializar o atributo trueName para nome, você pode adicionar @JSONField(value="name") ao nome get/set/property.

2.3 Comparação de vantagens e desvantagens

1. A anotação @JSONField é mais simples de usar. O valor padrão da anotação é igual ao nome da propriedade, enquanto @JsonProperty requer a especificação manual do nome da propriedade.

2. A anotação @JSONField oferece suporte a mais opções de mapeamento de atributos, como formato de data durante a serialização, como lidar com valores nulos, etc.

3. O desempenho da anotação @JSONField é mais rápido porque o próprio fastjson é uma biblioteca de processamento JSON de alto desempenho

4. Ao usar a estrutura Jackson, você só pode usar a anotação @JsonProperty e não pode usar a anotação @JSONField.

@JsonPropriedade

Se você estiver usando um novoprojeto springboot, o padrão é serialização Jackson, basta usar anotações diretamente nas propriedades.

1. Dependência

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>版本号</version>
</dependency>
1
2
3
4
5

• A anotação @JsonProperty vem do pacote jackson e é usada com o método ObjectMapper().writeValueAsString (classe de entidade) para converter a classe de entidade em uma string json.
• Usado com o método ObjectMapper().readValue(string) para converter strings json em classes de entidade.

2. Teste a conversão entre string json e objeto bean

Classe de entidade: User.java

import com.fasterxml.jackson.annotation.JsonProperty;
 
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
	@JsonProperty("JsonPropertyName")
	private String name;
	private String sex;
	private Integer age;
}

1
2
3
4
5
6
7
8
9
10
11
12

Métodos de teste:

@Test
public void testJsonProperty() throws IOException{
    //bean ---> json
	User user=new User("zhangsan","man",22);
	
	System.out.println(new ObjectMapper().writeValueAsString(user));
	

    //json ---> bean
	String str="{"sex":"man","age":22,"JsonPropertyName":"zhangsan"}";
	
	System.out.println(new ObjectMapper().readValue(str, User.class).toString());
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Resultado dos testes:

{"sex":"man","age":22,"JsonPropertyName":"zhangsan"}
User [name=zhangsan, sex=man, age=22]
1
2

• Pode-se observar que após o bean ser convertido em uma string json, o nome da propriedade do bean anotado com @JsonProperty foi substituído pelo nome da propriedade especificada: JsonPropertyName;

• Depois que a string json é convertida em um bean, o nome da propriedade especificado pela anotação @JsonProperty foi substituído pelo nome da propriedade do bean: name;

@Campo JSON

1. Dependência

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>版本号</version>
</dependency>
1
2
3
4
5

• @JSONField está localizado no pacote fastjson e é usado com o método JSON.toJSONString (classe de entidade) para converter classes de entidade em strings json.
• Use-o com o método JSON.parseObject(string, entidade class.class) para converter strings json em classes de entidade.

2. Teste a conversão entre string json e objeto bean

Classe de entidade: User.java

import com.alibaba.fastjson.annotation.JSONField;
 
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
	@JSONField(name="JSONFieldName")
	private String name;
	private String sex;
	private Integer age;
}
1
2
3
4
5
6
7
8
9
10
11

Métodos de teste:

@Test
public void testSONField(){
    //bean ---> json
	User user=new User("zhangsan","man",22);
	System.out.println(JSON.toJSONString(user));
	
    //json ---> bean
	String str="{"JSONFieldName":"zhangsan","age":22,"sex":"man"}";
	System.out.println(JSON.parseObject(str, User.class).toString());	
}
1
2
3
4
5
6
7
8
9
10

Resultado dos testes:

{"JSONFieldName":"zhangsan","age":22,"sex":"man"}
User [name=zhangsan, sex=man, age=22]
1
2

1. Pode-se observar que após o bean ser convertido em uma string json, o nome do atributo do bean da anotação @JSONField foi substituído pelo nome do atributo especificado: JSONFieldName;
2. Depois que a string json é convertida em um bean, o nome do atributo especificado pela anotação @JSONField foi substituído pelo nome do atributo do bean: name;
3. Os resultados do teste são iguais aos de @JsonProperty.

3. atributo de formato

O atributo format pode ser usado para especificar o formato dos atributos de tipo de data e o formato de conversão de tipos numéricos em tipos de string.

public class User {
    private String name;
    private int age;
    @JSONField(format = "yyyy-MM-dd")
    private Date birthday;
    @JSONField(format = "#,###.00")
    private double salary;
}
1
2
3
4
5
6
7
8

• No exemplo acima, a anotação @JSONField é usada para especificar o formato de data do atributo aniversário como “aaaa-MM-dd”
• O formato numérico do atributo salário é "#,###.00"

4. serializar atributo

• Você pode controlar se os atributos são serializados em objetos JSON por meio do atributo serialize.
• Quando o atributo serialize for falso, as propriedades não serão serializadas no objeto JSON. O padrão é verdadeiro.

public class User {
    @JSONField(serialize = false)
    private int userId;
    private String name;
    private int age;
}
1
2
3
4
5
6

No exemplo acima, o atributo userId é excluído da serialização usando a anotação @JSONField

5.deserializar atributo

• O atributo deserialize pode ser usado para controlar se as propriedades no objeto JSON são desserializadas em objetos Java.
• Quando o atributo deserializar for falso, esse atributo não será desserializado do objeto JSON para o objeto Java. O padrão é verdadeiro.

public class User {
    private int userId;
    private String name;
    @JSONField(deserialize = false)
    private int age;
}
1
2
3
4
5
6

No exemplo acima, a propriedade age é excluída da desserialização usando a anotação @JSONField

6. atributo ordinal

A ordem dos atributos pode ser especificada através do atributo ordinal

• Por padrão, a ordem das propriedades é baseada na ordem em que as propriedades aparecem no objeto Java.

public class User {
    @JSONField(ordinal = 2)
    private String name;
    @JSONField(ordinal = 1)
    private int age;
}
1
2
3
4
5
6

No exemplo acima, a anotação @JSONField é usada para especificar a ordem do atributo age como 1 e a ordem do atributo name como 2.

Atributo 7.defaultValue

O atributo defaultValue pode ser usado para especificar o valor padrão do atributo no objeto Java.

public class User {
    @JSONField(defaultValue = "0")
    private int userId;
    @JSONField(defaultValue = "N/A")
    private String name;
    private int age;
}
1
2
3
4
5
6
7

No exemplo acima, a anotação @JSONField é usada para especificar que o valor padrão do atributo userId é 0 e o valor padrão do atributo name é "N/A"

8. digite atributo

• O tipo de atributo pode ser especificado através do atributo type

public class User {
    private int userId;
    @JSONField(type = FieldType.STRING)
    private int age;
}
1
2
3
4
5

No exemplo acima, a anotação @JSONField é usada para especificar o tipo do atributo age como um tipo de string.