如何使用gson解析泛型形参并返回相对应的类

在android实际开发中，我们在请求网络数据的时候，服务器返回的通常都是json字符串，我们需要将json转化成我们需要的类，当然这些通常是使用gson来完成的，过程大概就是要判断解析后的类是否存在，类是否有效，类字段是否有值，其实这些逻辑都差不多，所以就会导致有很多重复的地方，这个时候我就想到用泛型来处理这个过程。

先看看我新建的项目空间：



类文件介绍

HttpResponse.java

//网络请求数据所对应的java类
//code:0表示请求数据成功；不为0则表示失败
//msg:如果网络请求失败，代表失败原因
//result:实际业务数据
public class HttpResponse {

private String msg;
private String code;
private Object result;

public String getMsg() {
return msg;
}

public String getCode() {
return code;
}

public Object getResult() {
return result;
}

public void setMsg(String msg) {
this.msg = msg;
}

public void setCode(String code) {
this.code = code;
}

public void setResult(Object result) {
this.result = result;
}

}

MyListener.java

//网络请求接口回调,这里使用了泛型，不考虑用interface
package study.fanxing.bean;

public abstract class MyListener<T> {

public abstract void success(T t);
public abstract void fail(String msg);
}

Student.java和Teacher.java(这两个是业务类，为了方便测试，这两个类的字段都是一样的)

package study.fanxing.bean;

public class Student {

private String name;
private String address;
private int age;
private String sex;

public Student() {

}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

}

Test1.java

package study.fanxing.test;

import com.google.gson.Gson;

import study.fanxing.bean.HttpResponse;
import study.fanxing.bean.MyListener;
import study.fanxing.bean.Student;
import study.fanxing.bean.Teacher;

public class Test1 {

public static Gson gson=new Gson();
//模拟实际的网络请求，注意这里只传了一个参数
public static <T> void requestNetworkData(MyListener<T> listener) {
HttpResponse response=null;
try {
response=gson.fromJson(getJson(), HttpResponse.class);
}catch(Exception e) {
e.printStackTrace();
}

//数据解析并且请求成功
if(response!=null && response.getCode().equals("0")) {
String type=TTypeUtils.getTType(listener.getClass());
if(type!=null && type.length()>0) {
T t=null;
try {
String json=gson.toJson(response.getResult());
Class<T> clazz=(Class<T>) Class.forName(type);
t=gson.fromJson(json, clazz);
}catch(Exception e) {
e.printStackTrace();
}

if(t!=null)
listener.success(t);
else
showError(response, listener);
} else {
showError(response, listener);
}
} else {
showError(response, listener);
}
}

//处理请求错误，解析错误这种情况
private static void showError(HttpResponse response,MyListener listener) {
if(response!=null && response.getMsg()!=null && response.getMsg().length()>0)
listener.fail(response.getMsg());
else
listener.fail("网络错误");
}

//请求student接口
public static void testRequestStudent() {
requestNetworkData(new MyListener<Student>() {

@Override
public void success(Student student) {
// TODO Auto-generated method stub
System.out.println("student:");
System.out.println("name:"+student.getName());
System.out.println("sex:"+student.getSex());
System.out.println("address:"+student.getAddress());
System.out.println("age:"+student.getAge());
}

@Override
public void fail(String msg) {
// TODO Auto-generated method stub
System.out.println(msg);
}
});
}
//请求teacher接口
public static void testRequestTeacher() {
requestNetworkData(new MyListener<Teacher>() {

@Override
public void success(Teacher t) {
// TODO Auto-generated method stub
System.out.println("teacher:");
System.out.println("name:"+t.getName());
System.out.println("sex:"+t.getSex());
System.out.println("address:"+t.getAddress());
System.out.println("age:"+t.getAge());
}

@Override
public void fail(String msg) {
// TODO Auto-generated method stub
System.out.println(msg);
}
});
}

//生成测试json
public static void createJson() {
HttpResponse response=new HttpResponse();
response.setCode("0");
response.setMsg("成功");
Student student=new Student();
student.setName("张三");
student.setAddress("中国");
student.setAge(15);
student.setSex("男");
response.setResult(student);
System.out.println(gson.toJson(response));
}

public static String getJson() {
return "{\"msg\":\"成功\",\"code\":\"0\",\"result\":{\"name\":\"张三\",\"address\":\"中国\",\"age\":15,\"sex\":\"男\"}}";
}

public static void main(String[] args) {

//      createJson();
testRequestStudent();
testRequestTeacher();
}
}

TTypeUtils.java

package study.fanxing.test;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

//这个类很关键，用来获取泛型类里面泛型的实际类型
public class TTypeUtils {

public static String getTType(Class<?> clazz) {
Type mySuperClassType=clazz.getGenericSuperclass();
Type[] types=((ParameterizedType)mySuperClassType).getActualTypeArguments();
if(types!=null && types.length>0) {
String[] TType=types[0].toString().split(" ");
if(TType!=null && TType.length>1) {
return TType[1];
}
}
return null;
}

}

那我们来看一下运行的效果：



从结果上看，已经正确的解析了json。从整个网络请求来看，只需要传入一个MyListener（T：具体的类类型，例如Student，Teacher）就可以获取实际的业务类，不需要每次都要判断一大推HttpResponse的逻辑，使用起来非常方便。当然如果返回的业务json是一个数组，我相信也可以做出来，大家可以自己试试。

当然还有可以优化的地方，例如HttpResponse里面的result字段可以没有，可以在MyListener.java类里面定义result字段，这样使用android官方自带的JSONObject获取result：JSONObject.optString(“result”)，这样使用起来会更方便。