Android 如何在改造请求的主体中发布原始的整个JSON？_Android_Rest_Http Post_Retrofit_Android Json

Android 如何在改造请求的主体中发布原始的整个JSON？

android rest

Android 如何在改造请求的主体中发布原始的整个JSON？,android,rest,http-post,retrofit,android-json,Android,Rest,Http Post,Retrofit,Android Json,这个问题以前可能被问过，但没有得到明确的回答。一个完整的JSON如何在改造请求的主体中发布见类似问题。或者这个答案正确吗？我真的希望不是这样，因为我连接到的服务只是希望文章正文中包含原始JSON。它们并不是为了寻找JSON数据的特定字段而设置的我只想和RESTPERT们一劳永逸地澄清这一点。一个人回答不使用改装。另一个不确定语法。另一个认为可以，但只有在表单url编码并放置在字段中时（在我的情况下，这是不可接受的）。不，我不能为我的Android客户端重新编码所有服务。是的，在大型项目中，发

这个问题以前可能被问过，但没有得到明确的回答。一个完整的JSON如何在改造请求的主体中发布

见类似问题。或者这个答案正确吗？我真的希望不是这样，因为我连接到的服务只是希望文章正文中包含原始JSON。它们并不是为了寻找JSON数据的特定字段而设置的

我只想和RESTPERT们一劳永逸地澄清这一点。一个人回答不使用改装。另一个不确定语法。另一个认为可以，但只有在表单url编码并放置在字段中时（在我的情况下，这是不可接受的）。不，我不能为我的Android客户端重新编码所有服务。是的，在大型项目中，发布原始JSON而不是将JSON内容作为字段属性值传递是非常常见的。让我们做好准备，继续前进。有人能指出说明如何做到这一点的文档或示例吗？或者提供可以/不应该这样做的有效理由

更新：有一件事我可以百分之百肯定地说。你可以在谷歌的截击中做到这一点。它是内置的。我们可以在改型中这样做吗？

注释定义了一个请求主体

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

由于改型默认使用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"}

本文将详细介绍对象序列化的工作原理

现在，如果您真的想自己发送“原始”JSON作为主体（但请使用Gson！），您仍然可以使用

TypedInput

：

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

定义为“具有关联mime类型的二进制数据”。有两种方法可以通过上述声明轻松发送原始数据：

用于发送原始字节和JSON mime类型：

String json = "{\"foo\":\"kit\",\"bar\":\"kat\"}";
TypedInput in = new TypedByteArray("application/json", json.getBytes("UTF-8"));
FooResponse response = foo.postRawJson(in);

创建

TypedJsonString

类的子类：

public class TypedJsonString extends TypedString {
  public TypedJsonString(String body) {
    super(body);
  }

  @Override public String mimeType() {
    return "application/json";
  }
}

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

除了类，我们还可以直接使用

HashMap

发送正文参数比如说

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

接口Foo{
@邮政（“/jayson”）
FooResponse postJson（@Body HashMap Body）；
}

我特别喜欢Jake关于

类型字符串

子类的建议。您确实可以根据您计划推送的POST数据类型创建各种各样的子类，每个子类都有自己的自定义一致调整集

您还可以选择在改型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 ) ;

使用

JsonObject

就是这样：

创建如下界面：

public interface laInterfaz{ 
    @POST("/bleh/blah/org")
    void registerPayer(@Body JsonObject bean, Callback<JsonObject> callback);
}

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<>();
    }
}

请致电该服务：

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());
    }
};

service.registerPayer（obj，callbackregisterpagador）；
Callback callbackRegistrador=new Callback（）{
public void成功（JsonObject对象，响应）{
System.out.println（object.toString（））；
}
公共无效故障（改型错误改型错误）{
System.out.println（error.toString（））；
}
};

这就是它！在我个人看来，这比制作POJO和处理班级混乱要好得多。这要干净得多。

是的，我知道现在已经晚了，但有人可能会从中受益

使用改型2:

昨晚我从截取迁移到改型2时遇到了这个问题（正如OP所说，这是通过

JsonObjectRequest

构建到截取中的），尽管杰克的答案对于改型1.9是正确的，但改型2没有

类型字符串
我的案例需要发送一个映射
，该映射可能包含一些空值，并转换为JSONObject（它不会与@FieldMap
一起飞行，特殊字符也不会飞行，有些会被转换），因此，请遵循@bnorms提示，如下所述：
可以指定一个对象作为带有@body注释的HTTP请求主体
还将使用改装实例上指定的转换器转换对象。如果未添加转换器，则只能使用RequestBody
因此，这是一个使用RequestBody
和ResponseBody
的选项：
在界面中，将@Body
与RequestBody

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

希望这对任何人都有帮助

上述版本的优雅Kotlin版本，允许在应用程序代码的其余部分从JSON转换中提取参数：
interface ServiceApi {

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

}

class ServiceApiUsingClass {

//ServiceApi init

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

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

接口服务API{
@POST（“/api/login”）
fun jsonLogin（@Body参数：RequestBody）：延迟
}
类服务使用类{
//ServiceApi初始化
有趣的登录（用户名：String，密码：String）=
jsonLogin（createJsonRequestBody(
“用户名”到用户名，“密码”到密码）
private fun createJsonRequestBody（vararg参数：Pair）=
RequestBody.create(
okhttp3.MediaType.parse（“application/json；charset=utf-8”），
JSONObject（mapOf（*params））.toString（）
}
在2中，当您想以原始格式发送参数时，必须使用标量
首先将此项添加到您的渐变中：
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);

}

公共接口{
字符串URL_BASE=”http://10.157.102.22/rest/";
@标题（“内容类型：application/json”）
@发布（“登录”）
调用getUser（@Body字符串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) {
    }
}

公共类SampleActivity扩展AppCompative实现回调{
@凌驾
创建时受保护的void（@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_示例）；
改装改装=新改装.Builder（）
.baseUrl（apinterface.URL\u BASE）
.addConverterFactory（ScalarsConverterFactory.create（））
   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) {
    }
}

 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'

    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;
        }
    }


}

    public interface Webservices {

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

}

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

 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;
}

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();
    }
}

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());

@Body RequestBody key

{
    "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<>();
    }
}

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

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

@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)

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();

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

   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>

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

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

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

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

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

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;
    }
}

@POST("/api/apiname")
Call<BaseResponse> apicall(@Body RequestBody params);

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();

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

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

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

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

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

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);
}

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) {

        }
    });

}

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

@POST("/urlPath")
@FormUrlEncoded
Call<Response> myApi(@Header("Authorization") String auth, @Header("KEY") String key, 
                     @Body JsonObject/POJO/String 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);

 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()

@Headers("Content-Type: application/json")
@POST("/set_data")
Call<CommonResponse> setPreferences(@Body RequestData request);

import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class RequestData {

    @SerializedName("access_token")
    @Expose
    private String accessToken;

    @SerializedName("data")
    @Expose
    private Data data;
    // The above 'Data' is another similar class to add inner JSON objects. JSONObject within a JSONObject.

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }

    public void setData(Data data) {
        this.data = data;
    }
}

@Headers({ "Content-Type: application/json;charset=UTF-8"})
    @POST("Auth/Login")
    Call<ApiResponse> loginWithPhone(@Body HashMap<String, String> fields);

 HashMap<String,String> SendData =new HashMap<>();
        SendData.put("countryCode",ccode);
        SendData.put("phoneNumber",phone);

        Call<ApiResponse>call = serviceInterface.loginWithPhone(SendData);