使用 Retrofit2 在 POST 请求中发送 JSON

Question

I'm using Retrofit to integrate my Web services and I do not understand how to send a JSON object to the server using a POST request. I'm currently stuck, here is my code:

Activity:-

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);


    Retrofit retrofit = new Retrofit.Builder().baseUrl(url).
            addConverterFactory(GsonConverterFactory.create()).build();

    PostInterface service = retrofit.create(PostInterface.class);

    JSONObject jsonObject = new JSONObject();
    try {
        jsonObject.put("email", "device3@gmail.com");
        jsonObject.put("password", "1234");
    } catch (JSONException e) {
        e.printStackTrace();
    }
    final String result = jsonObject.toString();

}

PostInterface:-

public interface PostInterface {

    @POST("User/DoctorLogin")
    Call<String> getStringScalar(@Body String body);
}

Request JSON:-

{
"email":"device3@gmail.com",
"password":"1234"
}

Response JSON:-

{
  "error": false,
  "message": "User Login Successfully",
  "doctorid": 42,
  "active": true
}

Answer 1

Use these in gradle

compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile 'com.squareup.retrofit2:converter-scalars:2.3.0'

Use these two POJO class ........

LoginData.class

public class LoginData {

    private String email;
    private String password;

    public LoginData(String email, String password) {
        this.email = email;
        this.password = password;
    }

    /**
     *
     * @return
     * The email
     */
    public String getEmail() {
        return email;
    }

    /**
     *
     * @param email
     * The email
     */
    public void setEmail(String email) {
        this.email = email;
    }

    /**
     *
     * @return
     * The password
     */
    public String getPassword() {
        return password;
    }

    /**
     *
     * @param password
     * The password
     */
    public void setPassword(String password) {
        this.password = password;
    }

}

LoginResult.class

public class LoginResult {

    private Boolean error;
    private String message;
    private Integer doctorid;
    private Boolean active;

    /**
     *
     * @return
     * The error
     */
    public Boolean getError() {
        return error;
    }

    /**
     *
     * @param error
     * The error
     */
    public void setError(Boolean error) {
        this.error = error;
    }

    /**
     *
     * @return
     * The message
     */
    public String getMessage() {
        return message;
    }

    /**
     *
     * @param message
     * The message
     */
    public void setMessage(String message) {
        this.message = message;
    }

    /**
     *
     * @return
     * The doctorid
     */
    public Integer getDoctorid() {
        return doctorid;
    }

    /**
     *
     * @param doctorid
     * The doctorid
     */
    public void setDoctorid(Integer doctorid) {
        this.doctorid = doctorid;
    }

    /**
     *
     * @return
     * The active
     */
    public Boolean getActive() {
        return active;
    }

    /**
     *
     * @param active
     * The active
     */
    public void setActive(Boolean active) {
        this.active = active;
    }

}

Use API like this

public interface RetrofitInterface {
     @POST("User/DoctorLogin")
        Call<LoginResult> getStringScalar(@Body LoginData body);
}

use call like this ....

Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("Your domain URL here")
            .addConverterFactory(ScalarsConverterFactory.create())
            .addConverterFactory(GsonConverterFactory.create())
            .build();

       RetrofitInterface service = retrofit.create(RetrofitInterface .class);

 Call<LoginResult> call=service.getStringScalar(new LoginData(email,password));
    call.enqueue(new Callback<LoginResult>() {
                @Override
                public void onResponse(Call<LoginResult> call, Response<LoginResult> response) { 
               //response.body() have your LoginResult fields and methods  (example you have to access error then try like this response.body().getError() )

              }

                @Override
                public void onFailure(Call<LoginResult> call, Throwable t) {
           //for getting error in network put here Toast, so get the error on network 
                }
            });

EDIT:-

put this inside the success() ....

if(response.body().getError()){
   Toast.makeText(getBaseContext(),response.body().getMessage(),Toast.LENGTH_SHORT).show();


}else {
          //response.body() have your LoginResult fields and methods  (example you have to access error then try like this response.body().getError() )
                String msg = response.body().getMessage();
                int docId = response.body().getDoctorid();
                boolean error = response.body().getError();  

                boolean activie = response.body().getActive()();   
}

Note :- Always use POJO classes , it remove the JSON data parsing in the retrofit .

Answer 2

This way works for me

My web service

Add this in your gradle

compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile 'com.squareup.retrofit2:converter-scalars:2.3.0'

Interface

public interface ApiInterface {

    String ENDPOINT = "http://10.157.102.22/rest/";

    @Headers("Content-Type: application/json")
    @POST("login")
    Call<User> getUser(@Body String body);

}

Activity

   public class SampleActivity extends AppCompatActivity implements Callback<User> {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sample);

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(ApiInterface.ENDPOINT)
                .addConverterFactory(ScalarsConverterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        ApiInterface apiInterface = retrofit.create(ApiInterface.class);


        // prepare call in Retrofit 2.0
        try {
            JSONObject paramObject = new JSONObject();
            paramObject.put("email", "sample@gmail.com");
            paramObject.put("pass", "4384984938943");

            Call<User> userCall = apiInterface.getUser(paramObject.toString());
            userCall.enqueue(this);
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void onResponse(Call<User> call, Response<User> response) {
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
    }
}

Answer 3

i think you should now create a service generator class and after that you should use Call to call your service

PostInterface postInterface = ServiceGenerator.createService(PostInterface.class);
Call<responseBody> responseCall =
            postInterface.getStringScalar(requestBody);

then you can use this for synchronous request and get the body of response:

responseCall.execute().body();

and for asynchronous :

responseCall.enqueue(Callback);

refer to link provided below for complete walkthrough and how to create ServiceGenerator :

https://futurestud.io/tutorials/retrofit-getting-started-and-android-client

Answer 4

From Retrofit 2+ use POJO objects rather than a JSON Object for sending requests with @Body annotations. With JSON object being sent the request fields are set to their default value than what has been sent from the app on backend. This won't be the case with POJO objects.