Fastjson反序列化泛型类型时候的一个问题

1. import static org.junit.Assert.assertFalse;
2. import static org.junit.Assert.assertTrue;
3. import java.util.ArrayList;
4. import java.util.List;
5. import org.junit.Test;
6. import com.alibaba.fastjson.JSON;
7. import com.alibaba.fastjson.JSONArray;
8. import com.alibaba.fastjson.TypeReference;
9. public class GenericTypeTest {
10. static class Foo<T>{
11. private T t;
12. public T getT() {
13. return t;
14. }
15. public void setT(T t) {
16. this.t = t;
17. }
18. }
19. @Test
20. public void test_FirstWithClass() {
21. Foo<List<Integer>> foo = new Foo<List<Integer>>();
22. List<Integer> list = new ArrayList<Integer>();
23. list.add(3);
24. foo.setT(list);
25. String v = JSON.toJSONString(foo);
26. System.out.println(v);
27. //parse with class
28. Foo<?> rst = JSON.parseObject(v, foo.getClass());
29. assertTrue(rst.getT() instanceof JSONArray);
30. //parse with TypeReference
31. rst = JSON.parseObject(v,new TypeReference<Foo<List<Integer>>>(){});
32. assertTrue(rst.getT() instanceof JSONArray);//这里没有失败
33. }
34. //  @Test//此用例跟上边那个不能同时跑，要不然上边跑过之后下边就跑不通了
35. public void test_FirstWithTypeReference() {
36. Foo<List<Integer>> foo = new Foo<List<Integer>>();
37. List<Integer> list = new ArrayList<Integer>();
38. list.add(3);
39. foo.setT(list);
40. String v = JSON.toJSONString(foo);
41. System.out.println(v);
42. //parse with TypeReference
43. Foo<?> rst = JSON.parseObject(v,new TypeReference<Foo<List<Integer>>>(){});
44. assertFalse(rst.getT() instanceof JSONArray);
45. }
46. }

文字描述的话就是：

1. 泛型类型反序列化调用paseObject的时候，第一次parseObject传Class，后边传TypeReference或者Type就解析不出泛型类型了，泛型对应的类型只能解析成JsonObject

版本1.2.4及以前，可以解析泛型的版本，应该都有。暂时可以通过含泛型的对象反序列化的时候，只通过传入Type或者TypeReference类型来实现。