如何在翻新请求的正文中发布原始的整个JSON?


284

可能以前曾问过这个问题,但没有明确回答。如何将原始的整个JSON发布到翻新请求的正文中?

在这里看到类似的问题。还是这个答案正确,它必须是形式url编码并作为字段传递?我真的希望不要,因为我要连接的服务只是在帖子正文中期待原始JSON。它们没有设置为寻找JSON数据的特定字段。

我只想用其余的一劳永逸地澄清一下。一个人回答不使用翻新。另一个不确定语法。另一个人认为是可以的,但前提是它的形式必须经过url编码并放在字段中(在我的情况下这是不可接受的)。不,我无法为我的Android客户端重新编码所有服务。是的,在大型项目中发布原始JSON而不是将JSON内容作为字段属性值传递是很常见的。让我们做对并继续前进。有人可以指出说明该操作的文档或示例吗?或提供一个有效的理由说明为什么/不应该这样做。

更新:我可以100%肯定地说一件事。您可以在Google的Volley中做到这一点。它是内置的。我们可以在翻新中做到这一点吗?


7
杰克·沃顿的职位是正确的!标记为答案!
edotassi 2014年

1
您可能会更好地使用jsonObject。
2015年

与完美的作品RequestBody这样的- > RequestBody body = RequestBody.create(MediaType.parse("text/plain"), text);查看详细的答案futurestud.io/tutorials/...
Kidus Tekeste

Answers:


461

@Body注解定义单个请求体。

interface Foo {
  @POST("/jayson")
  FooResponse postJson(@Body FooRequest body);
}

由于Retrofit默认使用Gson,因此FooRequest实例将作为请求的唯一主体序列化为JSON。

public class FooRequest {
  final String foo;
  final String bar;

  FooRequest(String foo, String bar) {
    this.foo = foo;
    this.bar = bar;
  }
}

致电:

FooResponse = foo.postJson(new FooRequest("kit", "kat"));

将产生以下内容:

{"foo":"kit","bar":"kat"}

GSON文档有更多的关于对象序列化是如何工作的。

现在,如果您真的想自己发送“原始” JSON作为主体(但是请使用Gson!),您仍然可以使用TypedInput

interface Foo {
  @POST("/jayson")
  FooResponse postRawJson(@Body TypedInput body);
}

TypedInput被定义为“具有关联的mime类型的二进制数据”。使用上面的声明有两种方法可以轻松发送原始数据:

  1. 使用TypedByteArray发送原始字节和JSON mime类型:

    String json = "{\"foo\":\"kit\",\"bar\":\"kat\"}";
    TypedInput in = new TypedByteArray("application/json", json.getBytes("UTF-8"));
    FooResponse response = foo.postRawJson(in);
  2. 子类TypedString创建一个TypedJsonString类:

    public class TypedJsonString extends TypedString {
      public TypedJsonString(String body) {
        super(body);
      }
    
      @Override public String mimeType() {
        return "application/json";
      }
    }

    然后使用类似于#1的该类的实例。


5
但是,非常好,有没有做pojos就可以做到这一点吗?
2015年

28
这不适用于改造2。TypedInput和TypedString类已删除。
艾哈迈德·黑格兹

2
@jakewharton TypedString自删除以来,我们该怎么办?
Jared Burrows

12
对于Retrofit2,您可以用于RequestBody创建原始实体。
bnorm '16

4
我收到此例外情况java.lang.IllegalArgumentException: Unable to create @Body converter for class MatchAPIRequestBody (parameter #1)
Shajeel Afzal

154

除了类,我们还可以直接使用HashMap<String, Object>来发送主体参数,例如

interface Foo {
  @POST("/jayson")
  FooResponse postJson(@Body HashMap<String, Object> body);
}

2
那时您可以创建像HashMap <String,Object>这样的Hash映射,它可以用于创建某种复杂的数组和对象JSON。
学习者

2
如果您不想被某种POJO所束缚,那就非常好。
蒂姆(Tim)

2
@无,您不能通过使用改造来发送json对象...您坚持使用pojo或我的答案...这是改造的本质。 。
学习者

5
IllegalArgumentException: Unable to create @Body converter for java.util.HashMap<java.lang.String, java.lang.Object>和莫西在一起。我认为GSON需要为这个工作
osrl

2
如果使用Kotlin,请使用<String,Any>的哈希表
peresisUser

148

是的,我知道已经晚了,但是有人可能会从中受益。

使用Retrofit2:

昨晚我从Volley迁移到Retrofit2时遇到了这个问题(并且正如OP所述,它是在Volley中内置的JsonObjectRequest),尽管Jake的答案是Retrofit1.9的正确答案,但Retrofit2却没有TypedString

我的情况要求发送一个Map<String,Object>可能包含一些空值的,将其转换为JSONObject(不会使用@FieldMap,特殊字符也不会转换,有些会被转换),因此遵循@bnorms提示,如Square所述

可以使用@Body注释将对象指定为HTTP请求正文。

该对象还将使用Retrofit实例上指定的转换器进行转换。如果未添加转换器,则只能使用RequestBody。

因此,这是使用RequestBody和的选项ResponseBody

在你的界面使用@BodyRequestBody

public interface ServiceApi
{
    @POST("prefix/user/{login}")
    Call<ResponseBody> login(@Path("login") String postfix, @Body RequestBody params);  
}

在您的调用点中,创建一个RequestBody,指出它是MediaType,然后使用JSONObject将您的Map转换为正确的格式:

Map<String, Object> jsonParams = new ArrayMap<>();
//put something inside the map, could be null
jsonParams.put("code", some_code);

RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),(new JSONObject(jsonParams)).toString());
//serviceCaller is the interface initialized with retrofit.create...
Call<ResponseBody> response = serviceCaller.login("loginpostfix", body);

response.enqueue(new Callback<ResponseBody>()
    {
        @Override
        public void onResponse(Call<ResponseBody> call, retrofit2.Response<ResponseBody> rawResponse)
        {
            try
            {
             //get your response....
              Log.d(TAG, "RetroFit2.0 :RetroGetLogin: " + rawResponse.body().string());
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }

        @Override
        public void onFailure(Call<ResponseBody> call, Throwable throwable)
        {
        // other stuff...
        }
    });

希望这对任何人有帮助!


上面的优雅Kotlin版本,允许从其余应用程序代码中的JSON转换中提取参数:

interface ServiceApi {

    fun login(username: String, password: String) =
            jsonLogin(createJsonRequestBody(
                "username" to username, "password" to password))

    @POST("/api/login")
    fun jsonLogin(@Body params: RequestBody): Deferred<LoginResult>

    private fun createJsonRequestBody(vararg params: Pair<String, String>) =
            RequestBody.create(
                okhttp3.MediaType.parse("application/json; charset=utf-8"), 
                JSONObject(mapOf(*params)).toString())

}

2
是的,为此,我看到了很多复杂的答案。如果您正在使用Retrofit2并想做排球比赛JsonObjectRequest,那么您要做的就是这个。好答案。
VicVu

2
Retrofit将一个名为“ nameValuePairs”的键添加到所有json对象的顶部。我如何删除此@TommySM
nr5

1
谢谢!这解决了我的问题。现在,我可以直接发送JSONObject,而无需创建POJO。
Erfan GLMPR

1
这是唯一帮助我访问post a null valuerequestBody中某个属性的解决方案,否则该属性将被忽略。
Shubhral

我知道我迟到了,但是jsonParams.put("code", some_code);第三行是什么?
Naveen Niraula

81

Retrofit2中,当您要原始发送参数时,必须使用Scalars

首先将其添加到您的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'

您的介面

public interface ApiInterface {

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

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

}

活动

   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.URL_BASE)
                .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) {
    }
}

9
这里的技巧是在Gson之前使用Scalar适配器,否则Gson会将您手动序列化的JSON包装在String中。
TWiStErRob

2
jonathan-nolasco-barrientos,您必须将.baseUrl(ApiInterface.ENDPOINT)更改为.baseUrl(ApiInterface.URL_BASE)
Milad Ahmadi

2
使用时GsonConverterFactory.toString()不需要。您可以声明Call<User> getUser(@Body JsonObject body);using JsonObject代替,JSONObject然后paramObject直接传递。它将正常工作。
Igor de Lorenzi

优秀而简单的方法。保存一天
Itai Spector

1
@IgordeLorenzi解决了我的问题,因为我正在使用Spring Boot来从gson中仅检索json的JsonObject正常工作
haidarvm

44

使用JsonObject方法是这样的:

  1. 像这样创建您的界面:

    public interface laInterfaz{ 
        @POST("/bleh/blah/org")
        void registerPayer(@Body JsonObject bean, Callback<JsonObject> callback);
    }
  2. 使JsonObject符合jsons结构。

    JsonObject obj = new JsonObject();
    JsonObject payerReg = new JsonObject();
    payerReg.addProperty("crc","aas22");
    payerReg.addProperty("payerDevManufacturer","Samsung");
    obj.add("payerReg",payerReg);
    /*json/*
        {"payerReg":{"crc":"aas22","payerDevManufacturer":"Samsung"}}
    /*json*/
  3. 致电服务:

    service.registerPayer(obj, callBackRegistraPagador);
    
    Callback<JsonObject> callBackRegistraPagador = new Callback<JsonObject>(){
        public void success(JsonObject object, Response response){
            System.out.println(object.toString());
        }
    
        public void failure(RetrofitError retrofitError){
            System.out.println(retrofitError.toString());
        }
    };

那就是它!我个人认为,这比制作pojos和处理班级混乱要好得多。这要干净得多。


1
如果我不想在jsonobject类中发送指定值怎么办。我可以在上述验证中使用哪种注释?
阿里·古瑞利(AliGürelli)'16

1
如您所见,上面的示例... JsonObject是一个对象,不使用任何注释。在您的情况下,如果您不想发送特定值,则可能只是不将其添加为属性...
superUser 2016年

1
我的意思是我不想发送在类中声明的值。顺便说一句,我解决了这个问题。有一个公开名称的注释。
阿里·古瑞利

2
这是最灵活的方式。即使您不知道将拥有多少个字段,或者即使您不知道它们从我那里获得+1的名称,您也可以构造json对象
Stoycho Andreev

1
即时错误服务方法无法返回void。APIServices.signUpUser的方法
Erum

11

我特别喜欢的杰克的建议TypedString子类以上。实际上,您可以根据计划要推送的各种POST数据创建各种子类,每个子类都有自己的自定义一致调整集。

您还可以选择在Re​​trofit API中向JSON POST方法添加标头注释…

@Headers( "Content-Type: application/json" )
@POST("/json/foo/bar/")
Response fubar( @Body TypedString sJsonBody ) ;

…但是使用子类显然更能自我记录。

@POST("/json/foo/bar")
Response fubar( @Body TypedJsonString jsonBody ) ;

1
通过使用来自JW建议的
TypedJsonString

10

1)添加依赖项

 compile 'com.google.code.gson:gson:2.6.2'
compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'

2)制作Api Handler类

    public class ApiHandler {


  public static final String BASE_URL = "URL";  

    private static Webservices apiService;

    public static Webservices getApiService() {

        if (apiService == null) {

           Gson gson = new GsonBuilder()
                    .setLenient()
                    .create();
            Retrofit retrofit = new Retrofit.Builder().addConverterFactory(GsonConverterFactory.create(gson)).baseUrl(BASE_URL).build();

            apiService = retrofit.create(Webservices.class);
            return apiService;
        } else {
            return apiService;
        }
    }


}

3)从Json schema 2 pojo制作bean类

记住
-目标语言:Java的 共源类型:JSON -Annotation风格:GSON -选择包含getter和setter -也可能会选择允许额外的属性

http://www.jsonschema2pojo.org/

4)使接口来回调用

    public interface Webservices {

@POST("ApiUrlpath")
    Call<ResponseBean> ApiName(@Body JsonObject jsonBody);

}

如果您有一个表单数据参数,则在行下方添加

@Headers("Content-Type: application/x-www-form-urlencoded")

表格数据参数的其他方式检查此链接

5)制作JsonObject作为参数传入主体

 private JsonObject ApiJsonMap() {

    JsonObject gsonObject = new JsonObject();
    try {
        JSONObject jsonObj_ = new JSONObject();
        jsonObj_.put("key", "value");
        jsonObj_.put("key", "value");
        jsonObj_.put("key", "value");


        JsonParser jsonParser = new JsonParser();
        gsonObject = (JsonObject) jsonParser.parse(jsonObj_.toString());

        //print parameter
        Log.e("MY gson.JSON:  ", "AS PARAMETER  " + gsonObject);

    } catch (JSONException e) {
        e.printStackTrace();
    }

    return gsonObject;
}

6)像这样打电话给Api

private void ApiCallMethod() {
    try {
        if (CommonUtils.isConnectingToInternet(MyActivity.this)) {
            final ProgressDialog dialog;
            dialog = new ProgressDialog(MyActivity.this);
            dialog.setMessage("Loading...");
            dialog.setCanceledOnTouchOutside(false);
            dialog.show();

            Call<ResponseBean> registerCall = ApiHandler.getApiService().ApiName(ApiJsonMap());
            registerCall.enqueue(new retrofit2.Callback<ResponseBean>() {
                @Override
                public void onResponse(Call<ResponseBean> registerCall, retrofit2.Response<ResponseBean> response) {

                    try {
                        //print respone
                        Log.e(" Full json gson => ", new Gson().toJson(response));
                        JSONObject jsonObj = new JSONObject(new Gson().toJson(response).toString());
                        Log.e(" responce => ", jsonObj.getJSONObject("body").toString());

                        if (response.isSuccessful()) {

                            dialog.dismiss();
                            int success = response.body().getSuccess();
                            if (success == 1) {



                            } else if (success == 0) {



                            }  
                        } else {
                            dialog.dismiss();


                        }


                    } catch (Exception e) {
                        e.printStackTrace();
                        try {
                            Log.e("Tag", "error=" + e.toString());

                            dialog.dismiss();
                        } catch (Resources.NotFoundException e1) {
                            e1.printStackTrace();
                        }

                    }
                }

                @Override
                public void onFailure(Call<ResponseBean> call, Throwable t) {
                    try {
                        Log.e("Tag", "error" + t.toString());

                        dialog.dismiss();
                    } catch (Resources.NotFoundException e) {
                        e.printStackTrace();
                    }
                }

            });

        } else {
            Log.e("Tag", "error= Alert no internet");


        }
    } catch (Resources.NotFoundException e) {
        e.printStackTrace();
    }
}

9

我发现,当您使用复合对象作为@Body参数时,它不能与Retrofit配合使用GSONConverter(假设您正在使用该对象)。您不必使用它,JsonObject而不必JSONObject在使用它,而是添加它NameValueParams而不必太冗长-您只能看到,如果添加了日志记录拦截器和其他恶作剧的另一个依赖关系。

因此,我发现解决此问题的最佳方法是使用RequestBody。您可以RequestBody通过简单的api调用将对象转到并启动它。就我而言,我正在转换地图:

   val map = HashMap<String, Any>()
        map["orderType"] = orderType
        map["optionType"] = optionType
        map["baseAmount"] = baseAmount.toString()
        map["openSpotRate"] = openSpotRate.toString()
        map["premiumAmount"] = premiumAmount.toString()
        map["premiumAmountAbc"] = premiumAmountAbc.toString()
        map["conversionSpotRate"] = (premiumAmountAbc / premiumAmount).toString()
        return RequestBody.create(MediaType.parse("application/json; charset=utf-8"), JSONObject(map).toString())

这是电话:

 @POST("openUsvDeal")
fun openUsvDeal(
        @Body params: RequestBody,
        @Query("timestamp") timeStamp: Long,
        @Query("appid") appid: String = Constants.APP_ID,
): Call<JsonObject>

2
很好,这对我过夜搜索后有所帮助。
W4R10CK

8

添加ScalarsConverterFactory进行改造:

在gradle中:

implementation'com.squareup.retrofit2:converter-scalars:2.5.0'

您的改造:

retrofit = new Retrofit.Builder()
            .baseUrl(WEB_DOMAIN_MAIN)
            .addConverterFactory(ScalarsConverterFactory.create())
            .addConverterFactory(GsonConverterFactory.create(gson))
            .build();

将您的调用接口@Body参数更改为String,不要忘记添加@Headers("Content-Type: application/json")

@Headers("Content-Type: application/json")
@POST("/api/getUsers")
Call<List<Users>> getUsers(@Body String rawJsonString);

现在您可以发布原始json。


6

如果您不想为每个API调用创建pojo类,则可以使用hashmap。

HashMap<String,String> hashMap=new HashMap<>();
        hashMap.put("email","this@gmail.com");
        hashMap.put("password","1234");

然后像这样发送

Call<JsonElement> register(@Body HashMap registerApiPayload);

4

经过这么多的努力,发现基本的区别是您需要发送JsonObject而不是JSONObjectas参数。


我也在犯同样的错误:p
Mehtab Ahmed '18

4

使用以下发送JSON

final JSONObject jsonBody = new JSONObject();
    try {

        jsonBody.put("key", "value");

    } catch (JSONException e){
        e.printStackTrace();
    }
    RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),(jsonBody).toString());

并将其传递给url

@Body RequestBody key

4

根据最高答案,我有一个解决方案,不必为每个请求都进行POJO。

例如,我要发布此JSON。

{
    "data" : {
        "mobile" : "qwer",
        "password" : "qwer"
    },
    "commom" : {}
}

然后,我创建一个像这样的通用类:

import java.util.Map;
import java.util.HashMap;

public class WRequest {

    Map<String, Object> data;
    Map<String, Object> common;

    public WRequest() {
        data = new HashMap<>();
        common = new HashMap<>();
    }
}

最后,当我需要一个json

WRequest request = new WRequest();
request.data.put("type", type);
request.data.put("page", page);

@Body然后,带有标记注释的请求可以传递给Retrofit。


4

如果您不想创建额外的类或使用JSONObject,可以使用HashMap

改造界面:

@POST("/rest/registration/register")
fun signUp(@Body params: HashMap<String, String>): Call<ResponseBody>

呼叫:

val map = hashMapOf(
    "username" to username,
    "password" to password,
    "firstName" to firstName,
    "surname" to lastName
)

retrofit.create(TheApi::class.java)
     .signUp(map)
     .enqueue(callback)

3

在Retrofit中发送原始json所需的东西。

1)确保添加以下标头,并删除其他重复的标头。由于在Retrofit的官方文档中,他们特别提到-

请注意,标头不会相互覆盖。具有相同名称的所有标头将包含在请求中。

@Headers({"Content-Type: application/json"})

2) 一个。如果您使用的是转换器工厂,则可以将JSON作为String,JSONObject,JsonObject甚至POJO进行传递。还检查了,ScalarConverterFactory没有必要只做GsonConverterFactory工作。

@POST("/urlPath")
@FormUrlEncoded
Call<Response> myApi(@Header("Authorization") String auth, @Header("KEY") String key, 
                     @Body JsonObject/POJO/String requestBody);

2)b。如果您不使用任何转换器工厂,则必须使用okhttp3的RequestBody,如Retrofit的文档所述:

该对象还将使用Retrofit实例上指定的转换器进行转换。如果未添加转换器,则只能使用RequestBody。

RequestBody requestBody=RequestBody.create(MediaType.parse("application/json; charset=utf-8"),jsonString);

@POST("/urlPath")
@FormUrlEncoded
Call<Response> myApi(@Header("Authorization") String auth, @Header("KEY") String key, 
                 @Body RequestBody requestBody);

3)成功!!


2

这对于retrofit 2.6.2的当前版本有效,

首先,我们需要将Scalars Converter添加到Gradle依赖项列表中,以将java.lang.String对象转换为text / plain请求主体,

implementation'com.squareup.retrofit2:converter-scalars:2.6.2'

然后,我们需要将转换器工厂传递给我们的改造制造商。稍后将告诉Retrofit如何转换传递给服务的@Body参数。

private val retrofitBuilder: Retrofit.Builder by lazy {
    Retrofit.Builder()
        .baseUrl(BASE_URL)
        .addConverterFactory(ScalarsConverterFactory.create())
        .addConverterFactory(GsonConverterFactory.create())
}

注意:在我的改造生成器中,我有两个转换器GsonScalars您可以同时使用它们,但是要发送Json主体,我们需要集中精力,Scalars因此如果您不需要Gson将其移除

然后使用String主体参数翻新服务。

@Headers("Content-Type: application/json")
@POST("users")
fun saveUser(@Body   user: String): Response<MyResponse>

然后创建JSON正文

val user = JsonObject()
 user.addProperty("id", 001)
 user.addProperty("name", "Name")

致电您的服务

RetrofitService.myApi.saveUser(user.toString())

2

✅✅✅✅✅✅✅✅✅✅✅✅ 工作解决方案 ✅✅✅✅✅✅✅✅✅✅✅✅

在创建时 OkHttpClient将用于翻新。

添加一个这样的拦截器。

 private val httpClient = OkHttpClient.Builder()
        .addInterceptor (other interceptors)
        ........................................

        //This Interceptor is the main logging Interceptor
        .addInterceptor { chain ->
            val request = chain.request()
            val jsonObj = JSONObject(Gson().toJson(request))

            val requestBody = (jsonObj
            ?.getJSONObject("tags")
            ?.getJSONObject("class retrofit2.Invocation")
            ?.getJSONArray("arguments")?.get(0) ?: "").toString()
            val url = jsonObj?.getJSONObject("url")?.getString("url") ?: ""

            Timber.d("gsonrequest request url: $url")
            Timber.d("gsonrequest body :$requestBody")

            chain.proceed(request)
        }

        ..............
        // Add other configurations
        .build()

现在,您的每一次改造调用的URL和请求主体将被记录Logcat筛选依据"gsonrequest"


1

我尝试了此操作:在创建Retrofit实例时,将此转换器工厂添加到Retrofit生成器中:

gsonBuilder = new GsonBuilder().serializeNulls()     
your_retrofit_instance = Retrofit.Builder().addConverterFactory( GsonConverterFactory.create( gsonBuilder.create() ) )

1

根据TommySM的答案解决了我的问题(请参阅上一个)。但是我不需要登录,我使用Retrofit2来测试https GraphQL API,如下所示:

  1. 借助json注释(导入jackson.annotation.JsonProperty)定义了我的BaseResponse类。

    public class MyRequest {
        @JsonProperty("query")
        private String query;
    
        @JsonProperty("operationName")
        private String operationName;
    
        @JsonProperty("variables")
        private String variables;
    
        public void setQuery(String query) {
            this.query = query;
        }
    
        public void setOperationName(String operationName) {
            this.operationName = operationName;
        }
    
        public void setVariables(String variables) {
            this.variables = variables;
        }
    }
  2. 在接口中定义了调用过程:

    @POST("/api/apiname")
    Call<BaseResponse> apicall(@Body RequestBody params);
  3. 在测试主体中称为apicall:创建MyRequest类型的变量(例如“ myLittleRequest”)。

    Map<String, Object> jsonParams = convertObjectToMap(myLittleRequest);
    RequestBody body = 
         RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),
                        (new JSONObject(jsonParams)).toString());
    response = hereIsYourInterfaceName().apicall(body).execute();

0

为了使此处给出的答案更加清楚,这就是您可以使用扩展功能的方式。仅当您使用Kotlin时

如果您使用的com.squareup.okhttp3:okhttp:4.0.1是较旧的创建MediaTypeRequestBody对象的方法,则不建议在Kotlin中使用它们

如果要使用扩展功能从字符串中获取MediaType对象和ResponseBody对象,请首先将以下行添加到希望使用它们的类中。

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody

您现在可以通过这种方式直接获取MediaType的对象

val mediaType = "application/json; charset=utf-8".toMediaType()

要获取RequestBody的对象,首先以这种方式将要发送的JSONObject转换为字符串。您必须将mediaType对象传递给它。

val requestBody = myJSONObject.toString().toRequestBody(mediaType)

0

我想比较截击和翻新的速度,以发送和接收下面代码编写的数据(翻新部分)

第一依赖:

dependencies {
     implementation 'com.squareup.retrofit2:retrofit:2.4.0'
     implementation 'com.squareup.retrofit2:converter-gson:2.4.0'
}

然后界面:

 public interface IHttpRequest {

    String BaseUrl="https://example.com/api/";

    @POST("NewContract")
    Call<JsonElement> register(@Body HashMap registerApiPayload);
}

以及用于设置参数以将数据发布到服务器的函数(在MainActivity中):

private void Retrofit(){

    Retrofit retrofitRequest = new Retrofit.Builder()
            .baseUrl(IHttpRequest.BaseUrl)
            .addConverterFactory(GsonConverterFactory.create())
            .build();

    // set data to send
    HashMap<String,String> SendData =new HashMap<>();
    SendData.put("token","XYXIUNJHJHJHGJHGJHGRTYTRY");
    SendData.put("contract_type","0");
    SendData.put("StopLess","37000");
    SendData.put("StopProfit","48000");

    final IHttpRequest request=retrofitRequest.create(IHttpRequest.class);

    request.register(SendData).enqueue(new Callback<JsonElement>() {
        @Override
        public void onResponse(Call<JsonElement> call, Response<JsonElement> response) {
            if (response.isSuccessful()){
                Toast.makeText(getApplicationContext(),response.body().toString(),Toast.LENGTH_LONG).show();
            }
        }

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

        }
    });

}

在我的案例中,我发现Retrofit比凌空快。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.