Java JSON未从API调用解析

在这里看了很多，我没有发现类似的问题

我从我的API调用中得到JSON，但它不是解析。我经历了我使用的步骤，得到了一个解析错误，即

SyntaxError:JSON中的意外标记位于位置1

，我将发布下面所有内容的示例，希望有人能告诉我我做错了什么（我一直在用同样的东西来解析其他对象，但他们不知道为什么不能这样做）

预期的JSON

RegisterRequest.java

GsonRequest.java

公共类GsonRequest扩展了JsonRequest{
私有最终Gson Gson=新Gson（）；
私有映射；
私人期末班；
私有映射头；
私人回应。倾听者；
私有静态最终字符串内容\u TYPE=“CONTENT TYPE”；
专用静态最终字符串协议\u内容\u类型=
格式（“application/x-www-form-urlencoded”）；
公共GsonRequest（字符串url、类clazz、映射头、int方法、@Nullable-Map-bodyJson、，
Response.Listener，Response.ErrorListener ErrorListener）{
super（方法、url、getFormDataString（bodyJson）、侦听器、errorListener）；
this.clazz=clazz；
this.listener=listener；
this.bodyJson=bodyJson；
if（headers==null）{
this.headers=new HashMap（）；
}否则{
this.headers=标题；
}
this.headers.put（“client id”，Constants.API\u client\u id）；
this.headers.put（“client\u secret”，Constants.API\u client\u secret）；
this.headers.put（“接受编码”、“gzip、deflate、sdch”）；
}
私有静态字符串getFormDataString（映射formData）{
StringBuilder参数=新建StringBuilder（）；
if（formData！=null）{
for（字符串键：formData.keySet（））{
params.append（“&”）.append（key.append（“=”）.append（formData.get（key））；
}
返回params.toString（）子字符串（1）；
}否则{
返回null；
}
}
@凌驾
公共映射getParams（）引发AuthFailureError{
返回bodyJson！=null？bodyJson:super.getParams（）；
}
@凌驾
公共映射getHeaders（）引发AuthFailureError{
返回标题！=null？标题：super.getHeaders（）；
}
@凌驾
公共字符串getBodyContentType（）{
返回协议\内容\类型；
}
@凌驾
受保护的无效交付响应（T响应）{
onResponse（response）；
}
@凌驾
受保护的响应parseNetworkResponse（NetworkResponse响应）{
试一试{
字符串json；
字符串编码=response.headers.get（“内容编码”）；
if（encoding！=null&&encoding.equals（“gzip”））{
json=解包数据（response.data）；
}否则{
json=新字符串(
response.data，HttpHeaderParser.parseCharset（response.headers））；
}
返回Response.success（gson.fromJson（json，clazz），HttpHeaderParser.parseCacheHeaders（Response））；
}捕获（不支持的编码异常e）{
返回Response.error（新的ParseError（e））；
}捕获（JsonSyntaxException e）{
返回Response.error（新的ParseError（e））；
}
}
私有字符串数据（字节[]数据）{
字符串输出=”；
试一试{
gzip输入流gStream=新的gzip输入流（新的ByteArrayInputStream（数据））；
InputStreamReader reader=新的InputStreamReader（gStream）；
BufferedReader in=新的BufferedReader（读卡器）；
字符串读取；
而（（read=in.readLine（））！=null）{
输出+=读取；
}
reader.close（）；
in.close（）；
gStream.close（）；
}捕获（IOE异常）{
返回null；
}
返回输出；
}
}

---

任何帮助都将不胜感激，提前感谢：D

您期望的JSON在“email\u confirm”后的末尾有逗号：false，

---

请更正并重试。

记录您的响应。它看起来不是JSON，它的第一个字符是

s

。请尝试使用JSON.parse。并共享解析JSON的javascript代码片段。@Daenarys我应该在哪里添加它？@Bilal看起来像您在使用volley，使用VolleyLog.DEBUG=true启用日志；然后在functt中ion parseNetworkResponse（网络响应）请记录response.data并共享输出。@RishabhBhatia我在哪里可以找到输出的结果？我在我的日志中看不到任何内容。之后还有3个字段，并且最后一个字段上没有逗号。“user”是JSON对象。我没有看到任何从JSON对象提取数据以将其解析为RegisterResponse数据的规定。尝试一下在web api响应方法JSONObject userObject=obj.getJSONObject（“用户”）；Gson Gson=new Gson（）；RegisterResponse RegisterResponse=Gson.fromJson（userObject.toString（），RegisterResponse.class）中类似这样；实现相同的自定义json对象请求类。希望有帮助/I没有web api响应方法？很抱歉，这让我感到困惑您在@Override public void onResponse（RegisterResponse response）{registerFeedback.onRegisterSuccess（response）中得到响应；PreferenceConnector.writeString（mContext，“authToken”，response.getAccessToken（）；}但是您还没有为获取“用户”对象数据做任何准备。啊，是的，我现在明白了。我已经完成了您所说的，它可以工作了！谢谢：））

{
"user":{
    "id":1054776,
    "email":"fghrklhjkltghskj@gmail.com",
    "username":"user1496654688",
    "first_name":null,
    "last_name":null,
    "last_login":null,
    "email_confirmed":false
    }
}

public class RegisterRequest {

    private Context mContext;
    private Map<String, String> mCredentials;

    public interface RegisterFeedback{
        void onRegisterSuccess(RegisterResponse response);
        void onRegisterFailed(Exception exception);
    }

    public RegisterRequest(Context context) {
        mContext = context;
    }

    public void sendRegistration(String email, String password, RegisterFeedback feedback) {
        String url = Constants.BASE_URL + Constants.REGISTRATION_URL;
        Gson gson = new Gson();
        mCredentials = new HashMap<>();
        mCredentials.put("email", email);
        mCredentials.put("password", password);

        final RegisterFeedback registerFeedback = feedback;

        GsonRequest<RegisterResponse> request = new GsonRequest<>(url, RegisterResponse.class, null,
                Request.Method.POST, mCredentials, new Response.Listener<RegisterResponse>() {
            @Override
            public void onResponse(RegisterResponse response) {
                registerFeedback.onRegisterSuccess(response);
                PreferenceConnector.writeString(mContext, "authToken", response.getAccessToken());

            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                registerFeedback.onRegisterFailed(error);

            }
        });

        request.setRetryPolicy(new DefaultRetryPolicy(
                10000,
                DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
                DefaultRetryPolicy.DEFAULT_BACKOFF_MULT
        ));

        RequestFactory.getInstance(mContext).addtoRequestQueue(request);

    }

}

@Parcel
public class RegisterResponse {

    @SerializedName("id")
    private String id;
    @SerializedName("email")
    private String email;
    @SerializedName("username")
    private String username;
    @SerializedName("first_name")
    private String firstName;
    @SerializedName("last_name")
    private String lastName;
    @SerializedName("last_login")
    private String lastLogin;
    @SerializedName("email_confirmed")
    private String emailConfirmed;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getLastLogin() {
        return lastLogin;
    }

    public void setLastLogin(String lastLogin) {
        this.lastLogin = lastLogin;
    }

    public String isEmailConfirmed() {
        return emailConfirmed;
    }

    public void setEmailConfirmed(String emailConfirmed) {
        this.emailConfirmed = emailConfirmed;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

public class GsonRequest<T> extends JsonRequest<T> {

    private final Gson gson = new Gson();
    private Map<String, String> bodyJson;
    private final Class<T> clazz;
    private Map<String, String> headers;
    private Response.Listener<T> listener;
    private static final String CONTENT_TYPE = "Content-Type";

    private static final String PROTOCOL_CONTENT_TYPE =
            String.format("application/x-www-form-urlencoded");

    public GsonRequest(String url, Class<T> clazz, Map<String, String> headers, int method, @Nullable Map<String, String> bodyJson,
                       Response.Listener<T> listener, Response.ErrorListener errorListener) {

        super(method, url, getFormDataString(bodyJson), listener, errorListener);
        this.clazz = clazz;
        this.listener = listener;
        this.bodyJson = bodyJson;

        if (headers == null) {
            this.headers = new HashMap<>();
        } else {
            this.headers = headers;
        }

        this.headers.put("client-id", Constants.API_CLIENT_ID);
        this.headers.put("client_secret", Constants.API_CLIENT_SECRET);
        this.headers.put("Accept-Encoding", "gzip, deflate, sdch");
    }

    private static String getFormDataString(Map<String, String> formData){

        StringBuilder params = new StringBuilder();
        if (formData != null) {
            for (String key : formData.keySet()) {
                params.append("&").append(key).append("=").append(formData.get(key));
            }

            return params.toString().substring(1);
        }else {
            return null;
        }
    }

    @Override
    public Map<String, String> getParams() throws AuthFailureError {
        return bodyJson != null ? bodyJson : super.getParams();
    }

    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return headers != null ? headers : super.getHeaders();
    }

    @Override
    public String getBodyContentType() {
        return PROTOCOL_CONTENT_TYPE;
    }

    @Override
    protected void deliverResponse(T response){
        listener.onResponse(response);
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            String json;
            String encoding = response.headers.get("Content-Encoding");

            if (encoding != null && encoding.equals("gzip")) {
                json = unpackData(response.data);
            } else {
                json = new String (
                        response.data, HttpHeaderParser.parseCharset(response.headers));
            }

            return Response.success(gson.fromJson(json, clazz), HttpHeaderParser.parseCacheHeaders(response));


        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (JsonSyntaxException e) {
            return Response.error(new ParseError(e));
        }
    }

    private String unpackData(byte[] data) {
        String output = "";

        try {
            GZIPInputStream gStream = new GZIPInputStream(new ByteArrayInputStream(data));
            InputStreamReader reader = new InputStreamReader(gStream);
            BufferedReader in = new BufferedReader(reader);
            String read;
            while ((read = in.readLine()) != null) {
                output += read;
            }
            reader.close();
            in.close();
            gStream.close();
        } catch (IOException e) {
            return null;
        }

        return output;
    }


}