在json解析的时候,我们不同业务的Bean总有相同的地方,于是可以将其封装在一个基本类中,然后去专注核心业务。
public class BaseRespond<T> {
private int statusCode;
private String statusKey;
private String statusDesc;
private int count;
private long sysTime;
private T body;
public int getStatusCode() {
return statusCode;
}
public void setStatusCode(int statusCode) {
this.statusCode = statusCode;
}
public String getStatusKey() {
return statusKey;
}
public void setStatusKey(String statusKey) {
this.statusKey = statusKey;
}
public String getStatusDesc() {
return statusDesc;
}
public void setStatusDesc(String statusDesc) {
this.statusDesc = statusDesc;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public long getSysTime() {
return sysTime;
}
public void setSysTime(long sysTime) {
this.sysTime = sysTime;
}
public T getBody() {
return body;
}
public void setBody(T body) {
this.body = body;
}
@Override
public String toString() {
return "BaseRespond{" +
"statusCode=" + statusCode +
", statusKey='" + statusKey + '\'' +
", statusDesc='" + statusDesc + '\'' +
", count=" + count +
", sysTime=" + sysTime +
", body=" + body +
'}';
}
}
这个基本类里包含任何请求的基本返回参数以及一个 T 类型参数,这就是针对业务不同而变化的泛型参数。
自定义ParameterizedType
public class ParameterizedTypeImpl implements ParameterizedType {
private final Class raw;
private final Type[] args;
ParameterizedTypeImpl(Class raw, Type[] args) {
this.raw = raw;
this.args = args != null ? args : new Type[0];
}
@Override
public Type[] getActualTypeArguments() {
return args;
}
@Override
public Type getRawType() {
return raw;
}
@Override
public Type getOwnerType() {
return null;
}
}
ParameterizedType提供了泛型解析的规范,参数raw就是上述我们自定义的基本类,args核心业务bean类。
调用GSON解析
public static < T > BaseRespond< T > fromJsonObject(String reader, Class< T > clazz) {
Type type = new ParameterizedTypeImpl(BaseRespond.class, new Class[]{clazz});
return gson.fromJson(reader, type);
}
解析List
public static < T > BaseRespond< T > fromJsonObject(String reader, Class< T > clazz) {
Type typeList = new ParameterizedTypeImpl(List.class, new Class[]{clazz});
Type type = new ParameterizedTypeImpl(BaseRespond.class, new Type[]{type});
return gson.fromJson(reader, type);
}
为什么要使用封装(与TypeToken相比)
这里有个问题当上述我们通过 T 适配类型的时候如果调用
gson.fromJson(reader, new TypeToken < BaseRespond < T > >() {
}.getType());
无法正常解析,TypeToken里只能填入一个明确的类型才可以达到相同的效果。而使用封装就可以解决这个问题。
生成JSON串
gson.toJson();
fastJson同理,TypeReference里依然必须要有一个明确的类型