web-dev-qa-db-fra.com

Comment envoyer des données de formulaire dans retrofit2 android

Bonjour, j’ai un JSON à envoyer au serveur (POST METHORD) {"country":"india","devicetype":"Android"} il est dans le modèle de données de formulaire Comme la clé de ce json est data c’est le serveur qui l’accepte comme 

data={"country":"india","devicetype":"Android"} j'utilise retrofit J'utilise Multipart comme ceci

@Multipart
@POST("initiate")
@Headers({
        "Content-Type: application/json",
        "Cache-Control: no-cache"
})
Call<UserInfoServerResponse> getUserInfoRequest(@Part(value="data") UserInfo mUserInfo);

here UserInfo est le JSON, mais je reçois un message d'échec du serveur après que j'ai utilisé la méthode FormUrlEncoded.

 @FormUrlEncoded
@POST("initiate")
@Headers({
        "Content-Type: application/json",
        "Cache-Control: no-cache"
})
Call<UserInfoServerResponse> getUserInfoRequest(@Field(value="data",encoded = false) String mUserInfo);

sa sortie est aussi le même résultat d'échec du serveur, mais l'envoi des données au serveur est au format

data=%7B%22country%22%3A%22india%22%2C%22devicetype%22%3A%22%22%7D

Mon UserInfo.class 

public class UserInfo {


public String country;

public String devicetype;

public UserInfo( String country,String devicetype) {

    this.country=country;

    this.devicetype=devicetype;
}
}

Ma classe d'adaptateur

RemoteRetrofitInterfaces mService;
    Retrofit mRetrofit;
  HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(20, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS).addInterceptor(interceptor)
                .build();

        mRetrofit = new Retrofit.Builder()
                .baseUrl(AppConstant.Host).addConverterFactory(GsonConverterFactory.create())
                .client(client)
                .build();
        mService = mRetrofit.create(RemoteRetrofitInterfaces.class);

   Call<UserInfoServerResponse> api = mService.getUserInfoRequest(new Gson().toJson(mUserInfo));

        api.enqueue(new Callback<UserInfoServerResponse>() {
            @Override
            public void onResponse(Call<UserInfoServerResponse> responseCall, Response<UserInfoServerResponse> response) {

                if (response.body().status != null) {
                    if (response.body().status.equals("success")) {
                        Log.d(TAG, "success---");
                    }

                } else {
                    Log.d(TAG, "Failed---");

                }


            }

            @Override
            public void onFailure(Call<UserInfoServerResponse> responseCall, Throwable t) {
                t.printStackTrace();
            }


        });

alors, comment puis-je envoyer le JSON au serveur à l'aide de retrofit avec succès, je suis passé par le document retofit document et suivez quelques étapes, mais je ne reçois aucun résultat. quelqu'un peut-il m'aider dans cette

Je vous remercie

androidjsonretrofit2
8
Ramz

enfin, j'ai trouvé la solution espère que cela aidera un autre

je réalise la solution en utilisant FieldMap

de rattrapage.

@POST("initiate")
@FormUrlEncoded

Call<UserInfoServerResponse> getUserInfoRequest(@FieldMap Map<String,String> params);

et dans la section Rest Adapter, j’ai modifié les données de demande de chaîne en formulaire Hashmap comme suit

 Log.d(TAG, "sendUserInfo called");
UserInfo mInfo=new UserInfo("countyname","Android");
        String request=new Gson().toJson(mUserInfo);

        //Here the json data is add to a hash map with key data
        Map<String,String> params = new HashMap<String, String>();
        params.put("data", request);


        Call<UserInfoServerResponse> api = mService.getUserInfoRequest(params);


        api.enqueue(new Callback<UserInfoServerResponse>() {
            @Override
            public void onResponse(Call<UserInfoServerResponse> responseCall, Response<UserInfoServerResponse> response) {

                if (response.body().status != null) {
                    if (response.body().status.equals("success")) {
                        Log.d(TAG, "success---" + response.body());
                    }

                } else {
                    Log.d(TAG, "Failed---");

                }


            }

            @Override
            public void onFailure(Call<UserInfoServerResponse> responseCall, Throwable t) {
                t.printStackTrace();
            }


        });

Basiquement ce que j’ai utilisé @FormUrlEncoded pour les données de formulaire et @FieldMap pour mettre ma requête JSON en tant que valeur de clé. J'ai eu la solution en suivant cette méthode, espérons que cela aidera quelqu'un :)

12
Ramz

La solution ci-dessus fonctionne, mais son utilisation est lourde, une meilleure solution consiste à utiliser un convertisseur pour @Multipart formData

Veuillez utiliser le code ci-dessous pour continuer avec @Multipart FormData Cela est dû au fait que 

"" est ajouté à vos chaînes d'annonce

import Java.io.IOException;
import Java.lang.annotation.Annotation;
import Java.lang.reflect.Type;

import okhttp3.MediaType;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.Converter;
import retrofit2.Retrofit;

/**
 * Created by kural on 10/27/17.
 */

public class StringConverterFactory extends Converter.Factory {
private static final MediaType MEDIA_TYPE = MediaType.parse("text/plain");

public static StringConverterFactory create() {
        return new StringConverterFactory();
        }

@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
        if (String.class.equals(type)) {
        return new Converter<ResponseBody, String>() {

@Override
public String convert(ResponseBody value) throws IOException {
        return value.string();
        }
        };
        }
        return null;
        }

@Override
public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    if (String.class.equals(type)) {
        return new Converter<String, RequestBody>() {
            @Override
            public RequestBody convert(String value) throws IOException {
                return RequestBody.create(MEDIA_TYPE, value);
            }
        };
    }

    return null;

}
}

et dans votre client de modernisation ajoutez cette ligne

.addConverterFactory (StringConverterFactory.create ()) 

public class RetroFitClient {
    private static Retrofit retrofit = null;

    public static Retrofit getClient(String baseUrl) {
        if (retrofit==null) {
            HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
            interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
            OkHttpClient client = new OkHttpClient.Builder().addInterceptor(interceptor).build();

            /*retrofit = new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .client(client)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();*/
            retrofit = new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .client(client)
                    .addConverterFactory(StringConverterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();


        }
        return retrofit;
    }
1
mughil

Cela fonctionne bien pour moi et renvoie un json pour obtenir un nouveau jeton Microsoft Azure valide:

Mon point final: 

@PostMapping(value = "/get-new-token", consumes = {"application/JSON"}, produces = {"application/JSON"})
@Timed
public ResponseEntity<String> getNewToken(@RequestBody String refreshToken) throws IOException {
    JSONObject json = tokenService.getNewTokenByRefreshToken(refreshToken);
    return new ResponseEntity<>(json.toString(), HttpStatus.OK);
}

Mon getGraphRepository :

public GraphRepository getGraphRepository() {
    HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
    interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

    OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(interceptor).build();

    // Create and configure the Retrofit object
    Retrofit retrofit = new Retrofit.Builder()
        .baseUrl(" https://login.microsoftonline.com")
        .client(client)
        .addConverterFactory(JacksonConverterFactory.create())
        .build();

    // Generate the graph repo
    return retrofit.create(GraphRepository.class);
}

Mon service de jetons: 

public JSONObject getNewTokenByRefreshToken(String refreshToken) throws IOException {
    GraphRepository graphRepository = getGraphRepository();

    // My list of -> Key : Value
    Map<String,String> params = new HashMap<String, String>();
    params.put("grant_type", "refresh_token");
    params.put("client_id", this.client_id);
    params.put("client_secret", client_secret);
    params.put("refresh_token", refreshToken);

    RefreshToken data = graphRepository.getRefreshToken(tenantId, params).execute().body();
    JSONObject json = new JSONObject(data);

    return json;
}

Mon GraphRepository: 

@POST("/{tenant_id}/oauth2/v2.0/token")
@FormUrlEncoded
Call<RefreshToken> getRefreshToken(
    @Path("tenant_id") String tenant_id,
    @FieldMap Map<String, String> params
);

J'espère que cela peut aider quelqu'un.

0
XenoX