Shulou(Shulou.com)06/02 Report--

FastJson how to deserialize to deal with generics, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain in detail for you, people with this need can come to learn, I hope you can gain something.

Json Analysis of Metropolis

In our daily coding work, we often develop or encounter such json structures.

{"resultcode": "200"," reason ":" successful return "," result ": {" area ":" Pingyang County, Wenzhou City, Zhejiang Province "," sex ":" male "," birthday ":" March 8, 1989 "}}

For the provider of the interface, the outermost resultcode reason and result elements are available. So we can define a Response class like this

Public class Response {private String resultcode; private String reason; private T result;}

Use generics to determine what result ultimately fills in. Of course, what is populated here is an object, so let's also define it as a User class

Public class User {private String area; private String sex; private String birthday;}

In this way, our data can be returned to the caller in accordance with the agreed rules of the example json. As the caller, the machine that receives this data, we need to define the following class ResopnseUser

Public class ResopnseUser {private String resultcode; private String reason; private User result;} public class User {private String area; private String sex; private String birthday;}

Then we can use fastJson for pleasant parsing.

String testJson = "{\" resultcode\ ":\" 200\ ",\" reason\ ":\" successfully returned\ ",\" result\ ": {\" area\ ":\" Pingyang County, Wenzhou City, Zhejiang Province\ ",\" sex\ ":\" male\ ",\" birthday\ ":\" March 8, 1989\ "}"; ResponseUser response1 = JSONObject.parseObject (testJson,ResponseUser.class)

You can see, and we do get the results we want.

Thinking about improvement measures

But there is a less serious consequence. Every time I interface with the provider, I have to generate a corresponding class. Over time, these specialized classes will become more and more, and the nesting will become deeper and deeper. Since the provider can abstract a Response class, can I handle it in the same way as the provider?

String testJson = "{\" resultcode\ ":\" 200\ ",\" reason\ ":\" successfully returned\ ",\" result\ ": {\" area\ ":\" Pingyang County, Wenzhou City, Zhejiang Province\ ",\" sex\ ":\" male\ ",\" birthday\ ":\" March 8, 1989\ "}"; Response response = JSONObject.parseObject (testJson,Response.class)

Unfortunately, the result we got is not what we expected. Only the outermost data has been parsed successfully, and the inner result is still JSONObject.

Turn to the omnipotent forum

Fortunately, among the thousands of engineers, it is not the only one who has come up with this solution, and someone has already solved this kind of problem! Through various searches, we found that fastJson provides the class TypeReference, which can solve our problems.

String testJson = "{\" resultcode\ ":\" 200\ ",\" reason\ ":\" successfully returned\ ",\" result\ ": {\" area\ ":\" Pingyang County, Wenzhou City, Zhejiang Province\ ",\" sex\ ":\" male\ ",\" birthday\ ":\" March 8, 1989\ "}"; Response response = JSONObject.parseObject (testJson,new TypeReference () {})

Well, we've got the desired results, and we can finally unify the judgment of the outermost return values of all interfaces.

Never stop there.

Wait, didn't you find anything wrong? Generics perform type erasure at compile time! That's why the first time we used Response response = JSONObject.parseObject (testJson,Response.class); directly, it didn't work. So, even if we wrote new TypeReference () {}, wouldn't it still be erased? How does the runtime get the actual type that we define? By looking at the source code of TypeReference, fortunately, the source code is very simple and the amount of code is small. The first thing to enter is its constructor protected TypeReference (). Through debug, we find that when the code reaches the second line, we have already got the generics we wrote.

Type superClass = getClass () .getGenericSuperclass (); Type type = ((ParameterizedType) superClass) .getActualTypeArguments () [0]

This code is very simple, get its parent class getGenericSuperclass () to get the actual type. Following up on the code, we can see that it calls a native method private native String getGenericSignature0 (); it gets some information about the class and the parent class, ClassRepository and Type. At this point, we look back and see that new TypeReference () {} actually creates an anonymous inner class of TypeReference, and the actual type information is obtained through the getGenericSuperclass () of that class.

Keep digging.

Let's review what we have gained and note that there are two points:

Generics perform type erasure at compile time.

Getting its parent class, getGenericSuperclass (), gets the actual type. Wait, these two points contradict each other. 1 said no, 2 said it could still be found, what on earth is going on? By looking at the compiled bytecode file, we found the answer.

This is the decompiled information of the class file containing the code Response response = JSONObject.parseObject (testJson,new TypeReference () {});. We can see that it has an extra LocalvariableTypeTable, and the Signature in it happens to store the actual type information. * * that is, the type has not been completely erased, and we can still get the type of the parameter by reflection. * * the so-called erase only erases the bytecode of the code property of the method. In addition, we also see that in the InnerClasses list, there is an inner class called Main$1, that is, our new TypeReference () {}

Summary

The problem of nested generics in json can be solved by JSONObject.parseObject (testJson,new TypeReference () {});. Convenient, fast and intuitive

You can get the real type through getClass (). GetGenericSuperclass ();. Verification code

/ / this class creates an anonymous subclass of HashMap HashMap subIntMap = new HashMap () {}; System.out.println (subIntMap.getClass (). GetSuperclass ()); Type subClassType = subIntMap.getClass (). GetGenericSuperclass (); if (subClassType instanceof ParameterizedType) {ParameterizedType p = (ParameterizedType) subClassType; for (Type t: p.getActualTypeArguments ()) {System.out.println (t) }}

Output result

Class java.util.HashMapclass java.lang.Stringclass java.lang.Integer

The type is not completely erased, and the type of the parameter can be obtained by reflection. Verification code

ResponseUser response = new ResponseUser (); Field field = response.getClass (). GetField ("result"); System.out.println ("result Type is" + field.getType ()); System.out.println ("result GenericType is" + field.getGenericType ()); public class ResponseUser {private String resultcode; private String reason; public List result;}

Output result

Is it helpful for result Type is interface java.util.Listresult GenericType is java.util.List to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.