This article has participated in the good article call order activity, click to see: back end, big front end double track submission, 20,000 yuan prize pool for you to challenge!”
demand
Recently, I made a requirement to invoke the REST interface of another service. It felt simple enough to get started quickly
To construct the Request class
public class User {
private String name;
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age; }}Copy the codePop, I come up a new
service.sendRequest(new User("niu".18));
Copy the codeIt’s been another day of hard work.
positioning
However, one night at 8 PM, the tester called me out of the blue to say that the call had failed, and because of the lack of printing itself, there was no way to specify what was wrong.
I would not think that such a simple code itself will be wrong, no way!!
After the network capture, I found that the received parameters are null, but I clearly called the constructor passed the parameters
Is there something supernatural going on?
After analysis, the overall data flow is:
The only place you can have a problem is where you serialize JSON, so the local tests confirm this:
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
}
Copy the codeThere is a problem, but instead of turning the serialization into an object with null properties, the exception is thrown directly
Exception in thread "main" com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class online.jvm.bean.User and no properties discovered to create BeanSerializer (to avoid exception.disable SerializationFeature.FAIL_ON_EMPTY_BEANS)
at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java: 77).Copy the codeBy querying the exception data, this exception is resolved by adding Jackson’s serialization configuration FAIL_ON_EMPTY_BEANS, which indicates that if a bean serializes to null, it will not fail
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(FAIL_ON_EMPTY_BEANS, false);
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
}
Copy the codeInstead of reporting an error, it returns an empty string, which results in receiving null attributes
Looking at the self-developed RPC framework, you can see that there is a configuration for the FAIL_ON_EMPTY_BEANS
To solve
Again, Jackson needs to call the bean’s getter method when serializing
1, write the getter and look at the result:
public class User {
private String name;
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName(a) {
return name;
}
public Integer getAge(a) {
return age;
}
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
{"name":"niu","age":18}}}Copy the code2. Or change the property access to public
public class User {
public String name;
public Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
{"name":"niu","age":18}}}Copy the codeBut what if you want the properties of the bean not to be exposed even the getter?
3, annotations,@JsonProperty
This is done using the @jsonProperty annotation provided by Jackson
public class User {
@JsonProperty("userName")
private String name;
@JsonProperty
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
// {"userName":"niu","age":18}}}Copy the codeTake a look at the source annotation for @jsonProperty
Marker annotation that can be used to define a non-static method as a "setter" or "getter" for a logical property (depending on its signature), or non-static object field to be used (serialized, deserialized) as a logical property.
Copy the codeAn annotation, if used on a property, is equivalent to defining a getter and setter for that property.
So if you have a getter and you have an @jsonProperty annotation, which one is going to prevail?
public class User {
@JsonProperty("userName")
private String name;
@JsonProperty
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName(a) {
return name;
}
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
// {"age":18,"userName":"niu"}}}Copy the codeWhat if you get the getter for a property that’s not there?
public class User {
@JsonProperty("userName")
private String name;
@JsonProperty
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName2(a) {
return name;
}
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
// {"age":18,"name2":"niu","userName":"niu"}}}Copy the codeThat means if there is@JsonPropertyComments, comments shall prevail first
Then use reflection to find all the get methods of the object class, then go to get, and then lowercase, as each key value of json, and the return value of the get method as value. Next, reflect the field and add it to json.
4. Special circumstances
There is a special case where a getter method is generated by Lombok and the property’s sub-first letter is uppercase:
@Getter
public class User {
@JsonProperty
private String nAme;
@JsonProperty
private Integer age;
public User(String name, Integer age) {
this.nAme = name;
this.age = age;
}
public static void main(String[] args) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
String request = objectMapper.writeValueAsString(new User("niu".18));
System.out.println(request);
// {"nAme":"niu","age":18,"name":"niu"}}}Copy the codeThis is because the getter lombok generates will capitalize the first letter of a property,
So what happens when you serialize is you change the uppercase between get and lowercase to lowercase, so you change NA to lowercase
So the serialization result will have two properties: name (getter) and name (annotation)
public String getNAme(a) {
return this.nAme;
}
Copy the codeIf we generate the getter ourselves with the idea shortcut,
After that, serialize the nAme
public String getnAme(a) {
return nAme;
}
Copy the codesummary
A lot of bugs occur in places where you think you don’t have a problem. It looks simple, but you need to be careful. At the same time, you need to pay more attention to the principle of serialization.
This article covers the bug process and solution hope to be helpful to you, bye.