自己写个解析类，就可以了。如：package com.njsoft.njapp.util;

import org.apache.commons.io.IOUtils;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import javax.net.ssl.SSLHandshakeException;


/**
* json工具解析类
*/
public class JsonUtils {

public static final ObjectMapper MAPPER = new ObjectMapper()
.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false)//是否允许忽略未知异常。
.configure(DeserializationConfig.Feature.UNWRAP_ROOT_VALUE, false)
.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true)//是否允许单个值为数据
.configure(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, false)//是否允许空的字符与对象
.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, false)//是否允许特殊字符
.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true); //是否允许单引号
// .configure(SerializationConfig.Feature.WRAP_ROOT_VALUE,true) //序列时允许自定义根元素
// .configure(SerializationConfig.Feature.INDENT_OUTPUT,true); //序列时是否缩放排列输出

/**
* 转换2集合
* @param type -转换类型
* @param bytes -传入数据
* @param
* @return
*/
public static List getList(Class type, byte[] bytes) {
if (null == bytes) {
return null;
}
List res = new ArrayList<>();
try {
T[] next = toBean(type, bytes);
if (null != next)
Collections.addAll(res, next);
} catch (Exception e){
e.printStackTrace();
return null;
};
return res;
}

/**
* 转换2集合
* @param type -转换类型
* @param data -传入数据
* @param
* @return
*/
public static List getList(Class type, String data) {
if (null == data) {
return null;
}
List res = new ArrayList<>();
try {
T[] objs = toBean(type, data);
if (null != objs)
Collections.addAll(res, objs);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return res;
}

/**
* 转换2对象
* @param type -转换类型
* @param bytes -传入数据
* @param
* @return
*/
public static T toBean(Class type, byte[] bytes) {
if (null == bytes) {
return null;
}
return toBean(type, new ByteArrayInputStream(bytes));
}

public static T toBean(Class type, InputStream is) {
T obj = null;
try {
obj = parse(is, type, null);
} catch (IOException e) {
e.printStackTrace();
}
return obj;
}

/**
* 转换2对象
* @param type -转换类型
* @param data -传入参数
* @param
* @return
*/
public static T toBean(Class type, String data) {
T obj = null;
try {
obj = parse(data, type, null);
} catch (IOException e) {
e.printStackTrace();
}
return obj;
}

/**
* 对获取到的网络数据进行处理
*
* @param inputStream -传入二进制流
* @param type -解析类型
* @param instance -解析实例
* @return
* @throws IOException
*/
private static T parse(InputStream inputStream, Class type, T instance) throws IOException {
InputStreamReader reader = null;
try {
reader = new InputStreamReader(inputStream);
String data = IOUtils.toString(reader);
// data = str2Json(data);
if (null != type) {
return MAPPER.readValue(data, type);
} else if (null != instance) {
return MAPPER.readerForUpdating(instance).readValue(data);
} else {
return null;
}
} catch (SSLHandshakeException e) {
throw new SSLHandshakeException("You can disable certificate checking by setting " +
"ignoreCertificateErrors on GitlabHTTPRequestor");
} finally {
IOUtils.closeQuietly(reader);
}
}

/**
* 对获取到的网络数据进行处理
* @param data -传入数据
* @param type -解析类型
* @param instance -解析实例
* @param
* @return
* @throws IOException
*/
private static T parse(String data, Class type, T instance) throws IOException {
try {
if (null != type) {
return MAPPER.readValue(data, type);
} else if (null != instance) {
return MAPPER.readerForUpdating(instance).readValue(data);
} else {
return null;
}
} catch (SSLHandshakeException e) {
throw new SSLHandshakeException("");
}
}

/**
* JSON字符串特殊字符处理，比如：“\A1;1300”
* @param strJson
* @return String
*/
public static String str2Json(String strJson) {
StringBuffer sb = new StringBuffer();
for(int i=0; i char ch = strJson.charAt(i);
switch(ch){
case '"':
sb.append("\\\"");
break;
case '\\':
sb.append("\\\\");
break;
case '\b':
sb.append("\\b");
break;
case '\f':
sb.append("\\f");
break;
case '\n':
sb.append("\\n");
break;
case '\r':
sb.append("\\r");
break;
case '\t':
sb.append("\\t");
break;
//case '/':
// sb.append("\\/");
// break;
default:
if((ch >= '\u0000' && ch <= '\u001F') || (ch >= '\u007F' && ch <= '\u009F') || (ch >= '\u2000' && ch <= '\u20FF')) {
String str = Integer.toHexString(ch);
sb.append("\\u");
for(int k=0; k<4-str.length(); k++) {
sb.append('0');
}
sb.append(str.toUpperCase());
}
else{
sb.append(ch);
}
}
}
return sb.toString();
}
}

注意：记得添加jackson包，然后用jackson的注解，你试试行不行。