Retrofit 요청 본문에 생 JSON을 게시하는 방법은 무엇입니까?
이 질문은 이전에 질문을 받았을 수 있지만 확실하게 대답하지는 않았습니다.Retrofit 요청의 본문 안에 전체 JSON을 정확히 어떻게 게시합니까?
여기에서 유사한 질문을 참조하십시오.아니면 이 답변이 url 인코딩되어 필드로 전달되어야 한다는 것이 맞습니까?제가 연결하고 있는 서비스는 단지 게시물 본문에 원시 JSON을 기대하고 있기 때문에, 저는 정말 그렇지 않기를 바랍니다.JSON 데이터에 대한 특정 필드를 찾도록 설정되지 않았습니다.
나는 단지 이것을 다른 전문가들과 완전히 명확히 하고 싶을 뿐입니다.한 사람은 Retrofit을 사용하지 말라고 대답했습니다.다른 하나는 구문에 대한 확신이 없었습니다.다른 사람들은 그것이 가능하다고 생각하지만 그것의 형태가 URL 인코딩되어 필드에 배치될 때만 가능하다고 생각합니다(나의 경우에는 허용되지 않습니다).아니요, Android 클라이언트의 모든 서비스를 재코딩할 수 없습니다.또한 JSON 컨텐츠를 필드 속성 값으로 전달하는 대신 원시 JSON을 게시하는 것은 주요 프로젝트에서 매우 일반적입니다.바로 잡고 넘어가자꾸나중에.이 작업이 수행되는 방법을 보여주는 문서나 예제를 누군가 가리켜 줄 수 있습니까?또는 수행할 수 없는 타당한 이유를 제공합니다.
업데이트: 100% 확실하게 말할 수 있는 한 가지.Google의 Volley에서 이 작업을 수행할 수 있습니다.내장되어 있습니다.Retrofit에서 할 수 있나요?
주석은 단일 요청 본문을 정의합니다.
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 문서에는 객체 직렬화가 어떻게 작동하는지에 대한 훨씬 더 많은 정보가 있습니다.
만약 " 몸으로 ( 이것을 할 수 .TypedInput:
interface Foo {
@POST("/jayson")
FooResponse postRawJson(@Body TypedInput body);
}
TypedInput은 "연결된 MIME 유형이 있는 이진 데이터"로 정의됩니다.위의 선언을 사용하여 원시 데이터를 쉽게 보낼 수 있는 두 가지 방법이 있습니다.
TypedByteArray를 사용하여 원시 바이트와 JSON mime 유형을 보냅니다.
String json = "{\"foo\":\"kit\",\"bar\":\"kat\"}"; TypedInput in = new TypedByteArray("application/json", json.getBytes("UTF-8")); FooResponse response = foo.postRawJson(in);하위 클래스 TypedString을 생성합니다.
TypedJsonString명령어:public class TypedJsonString extends TypedString { public TypedJsonString(String body) { super(body); } @Override public String mimeType() { return "application/json"; } }그런 다음 #1과 유사한 클래스의 인스턴스를 사용합니다.
네, 늦은 건 알지만, 누군가는 아마 이것으로 이득을 볼 거예요.
Retrofit2 사용:
에서 레트로핏 2로 이 상태로서,이되었습니다).JsonObjectRequest), 그리고 Jake의 대답이 Retrofit1.9에 대한 정답이지만 Retrofit2에는 없습니다.TypedString.
제 경우에는 이메일을 보내야 했습니다.Map<String,Object>JSONObject와 함께 값을 할 수 .@FieldMap특수 문자도 변환되지 않음). 따라서 @bnorms 힌트를 따르고 사각형에 의해 명시된 대로:
@Body 주석을 사용하여 HTTP 요청 본문으로 사용할 개체를 지정할 수 있습니다.
개체는 Retrofit 인스턴스에 지정된 변환기를 사용하여 변환됩니다.컨버터가 추가되지 않은 경우 RequestBody만 사용할 수 있습니다.
이 옵션은 다음을 사용하는 옵션입니다.RequestBody그리고.ResponseBody:
인터페이스에서 다음을 사용합니다.@Body와 함께RequestBody
public interface ServiceApi
{
@POST("prefix/user/{login}")
Call<ResponseBody> login(@Path("login") String postfix, @Body RequestBody params);
}
에 호지에만듭다니다음을을 합니다.RequestBodyMediaType이라고 말하고 JSONObject를 사용하여 지도를 올바른 형식으로 변환합니다.
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...
}
});
나머지 응용 프로그램 코드의 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())
}
는 수업대우또리직한사수있용다습니할접는신에▁the▁use다▁directly▁we있▁instead▁also니습을 직접 사용할 수도 있습니다.HashMap<String, Object>를 들어 본문 변수를 하려면 다음과 같이 .
interface Foo {
@POST("/jayson")
FooResponse postJson(@Body HashMap<String, Object> body);
}
Retrofit2에서 원시 파라미터를 전송하려면 스칼라를 사용해야 합니다.
먼저 이것을 당신의 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) {
}
}
용사를 합니다.JsonObject그것이 바로 그것입니다.
다음과 같이 인터페이스를 만듭니다.
public interface laInterfaz{ @POST("/bleh/blah/org") void registerPayer(@Body JsonObject bean, Callback<JsonObject> callback); }jsons 구조에 따라 jsonObject를 만듭니다.
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*/서비스 호출:
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()); } };
이상입니다!제 개인적인 생각으로는, 포조를 만들고 수업을 엉망으로 만드는 것보다 훨씬 낫습니다.이것이 훨씬 더 깨끗합니다.
개조할 Scalars Converter Factory 추가:
화려하게:
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();
인터페이스 String으로 하고, @Body @Body @String을 추가하는 것을 마십시오. 추가하는 것을 잊지 마십시오.@Headers("Content-Type: application/json"):
@Headers("Content-Type: application/json")
@POST("/api/getUsers")
Call<List<Users>> getUsers(@Body String rawJsonString);
이제 당신은 raw json을 게시할 수 있습니다.
는 특히 제이크의 .TypedString상층 계급실제로 푸시업하려는 POST 데이터의 종류를 기반으로 다양한 하위 클래스를 생성할 수 있으며, 각 하위 클래스에는 일관된 조정의 사용자 지정 집합이 있습니다.
Retrofit 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 ) ;
종속성 추가
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'
API 처리기 클래스 만들기
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;
}
}
}
Json schema 2 pojo에서 bean 클래스를 만듭니다.
요.
-대상 언어 : Java -Source type : JSON -Annotation style : Gson -Include getters and setters -또한 추가 속성 허용을 선택할 수 있습니다.
http://www.jsonschema2pojo.org/
API 호출로 인터페이스 만들기
public interface Webservices {
@POST("ApiUrlpath")
Call<ResponseBean> ApiName(@Body JsonObject jsonBody);
}
폼 데이터 매개 변수가 있는 경우 아래 행을 추가합니다.
@Headers("Content-Type: application/x-www-form-urlencoded")
폼 데이터 매개 변수에 대한 다른 방법은 이 링크를 확인하십시오.
매개 변수로 본문에 전달하기 위한 make 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;
}
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();
}
}
를 는저당복물로 할 때 했습니다.@BodyParams, 그것은 Retrofit's와 잘 작동할 수 없습니다.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>
이것이 현재 버전에서 작동하는 이유입니다.retrofit 2.6.2,
우선, scalars 컨버터를 gradle 종속성 목록에 추가해야 합니다. 이 목록은 java.lang 변환을 처리합니다.텍스트/일반 요청 본문에 개체를 문자열로 지정합니다.
implementation'com.squareup.retrofit2:converter-scalars:2.6.2'
그러면, 우리는 컨버터 공장을 우리의 Retrofit builder에게 전달해야 합니다.나중에 Retrofit에 서비스에 전달된 @Body 매개 변수를 변환하는 방법을 알려줍니다.
private val retrofitBuilder: Retrofit.Builder by lazy {
Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(ScalarsConverterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
}
에는 두 의 변환기가 : 내개빌더에는컨버두가개다참있고니습.
Gson그리고.Scalars다할 수 는 초점을 맞춰야 .Scalars그래서 만약 당신이 필요하지 않다면.Gson그것을 제거합니다.
그런 다음 String body 매개변수를 사용하여 서비스를 다시 적합시킵니다.
@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())
모든 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);
그렇게 많은 노력 끝에, 기본적인 차이점은 당신이 그것을 보내야 한다는 것을 발견했습니다.JsonObject에 JSONObject매개 변수로
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
추클만사용지않으려면하나들거를래가스않면▁if려▁orJSONObject를 사용할 수 있습니다.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)
Retrofit에서 raw json을 보내기 위해 필요한 것들.
다음 헤더를 추가하고 다른 중복 헤더를 제거해야 합니다.Retrofit의 공식 문서에서 그들은 구체적으로 다음과 같이 언급했습니다.
헤더는 서로 덮어쓰지 않습니다.이름이 같은 모든 헤더가 요청에 포함됩니다.
@Headers({"Content-Type: application/json"})
a. 컨버터 팩토리를 사용하는 경우 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);
b. 컨버터 공장을 사용하지 않는 경우에는 Retrofit의 문서에 나와 있듯이 okhttp3의 RequestBody를 사용해야 합니다.
개체는 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);
성공!!
위 답변을 바탕으로 모든 요청에 대해 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으로 넘어갈 수 있습니다.
여기에 제시된 답변을 보다 명확히 하기 위해 확장 기능을 사용할 수 있는 방법은 다음과 같습니다.이것은 코틀린을 사용하는 경우에만 해당됩니다.
사중인경우를 .com.squareup.okhttp3:okhttp:4.0.1MediaType 및 RequestBody의 개체를 만드는 이전 메서드는 더 이상 사용되지 않으며 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)
은 야해합니다설을 설정해야 .@Body 인터페이스
@Headers({ "Content-Type: application/json;charset=UTF-8"})
@POST("Auth/Login")
Call<ApiResponse> loginWithPhone(@Body HashMap<String, String> fields);
Raw Body를 Retrofit으로 전달하려면 다음을 사용합니다.
HashMap<String,String> SendData =new HashMap<>();
SendData.put("countryCode",ccode);
SendData.put("phoneNumber",phone);
Call<ApiResponse>call = serviceInterface.loginWithPhone(SendData);
이것은 나에게 효과가 있습니다.
토미를 기반으로 내 문제를 해결했습니다.SM 응답(이전 참조).하지만 로그인할 필요가 없었습니다. Retrofit2를 사용하여 https GraphQL API를 테스트했습니다.
json 주석(jackson.notation 가져오기)의 도움으로 나의 BaseResponse 클래스를 정의했습니다.Json Property).
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);테스트 본문에서 호출된 피콜: 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();
아래 코드로 작성한 데이터 송수신을 위한 발리와 레트로핏의 속도를 비교하고 싶습니다(레트로핏 부품의 경우).
첫 번째 종속성:
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);
}
및 데이터를 서버에 게시하기 위한 매개 변수를 설정하는 기능(In 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) {
}
});
}
그리고 제 경우에는 발리보다 레트로핏이 더 빠르다는 것을 알게 되었습니다.
API 호출
@Headers("Content-Type: application/json")
@POST("/set_data")
Call<CommonResponse> setPreferences(@Body RequestData request);
참고: GSON Retrofit 라이브러리 사용
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;
}
}
그것이 도움이 될 것이라고 생각합니다, 당신이 이미 가지고 있었을 수도 있는 모든 통합을 멈추고, 우리는 위의 코드 스니펫을 사용하기 위해 어떤 화려한 것도 필요하지 않습니다.저한테 딱 맞습니다.
2022년 업데이트된 솔루션:
가장 먼저 확인해야 할 것 중 하나는 당신의 게시물 요청이 우체부와 같은 제3자 API를 통해 작동하고 있다는 것입니다.이 페이지에서 솔루션을 발견하기 전에 이 작업을 수행했습니다.
다음 단계에서는 로깅 기능을 개조 인스턴스에 추가합니다.개조에 로깅을 추가하는 방법은 여기를 클릭하십시오.
로깅을 추가할 때 500 서버 오류가 발생했습니다. 엔드포인트가 포스트맨을 통해 작동한다는 사실을 바탕으로 오류가 포스트 메서드로 전달되는 데이터 형식과 관련이 있음을 알 수 있습니다.
복고형 설계자는 다음과 같이 되어야 합니다.
val retrofitInstance = Retrofit.Builder()
.baseUrl("https://pacific-tundra-61285.herokuapp.com/")
.addConverterFactory(ScalarsConverterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.client(httpClient)
.build()
이 게시물은 이 문제를 해결하는 데 많은 도움이 되었고 게시물 요청을 할 때 개체를 올바른 "application/json" 형식으로 변환하는 올바른 방법을 제공했습니다.코틀린 버전에서는 몇 가지 사용되지 않는 방법이 사용되었으며, 새 코드는 매우 유사합니다.
private fun createRequestBody(vararg params : Pair<String, Any>) =
JSONObject(mapOf(*params)).toString()
.toRequestBody("application/json; charset=utf-8".toMediaTypeOrNull())
개체와 관련된 다양한 유형을 처리할 수 있도록 쌍의 일반 값 매개 변수가 임의로 설정됩니다.
마지막으로 명확한 설명을 위해 실제 게시 방법과 게시 요청을 호출하는 데 사용되는 코드가 있습니다.
@POST("create/")
fun create(@Body params : RequestBody) : Call<YourObject>
val call = apiService.create(createRequestBody(
"string" to object // You should pass in any key and value pairs here.
마지막으로 평소와 같이 통화 대기열을 호출합니다.
시도해 봤습니다.Retrofit 인스턴스(instance)를 작성할 때 다음 컨버터 팩토리를 Retrofit Builder에 추가합니다.
gsonBuilder = new GsonBuilder().serializeNulls()
your_retrofit_instance = Retrofit.Builder().addConverterFactory( GsonConverterFactory.create( gsonBuilder.create() ) )
을 작성하는 동안. OkHttpClient그것은 Retrofit에 사용될 것입니다.
이렇게 가로채기를 추가합니다.
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()
이제 모든 Retrofit 콜의 URL과 요청 본문이 로그인됩니다.Logcat필터링 기준
ScalarsConverterFactory.create() 메서드를 추가하고 하드 코드를 전달합니다.
JSONObject에 오류가 표시됩니다. 사용하십시오.
JsonObject paramObject = newJsonObject(); paramObject.addProperty("loginId", vMobile_Email);
@Headers(value = "Content-Type: application/json")
@POST("api/Persona/Add")
Call<Persona> AddPersona(@Header("authorization") String token, @Body JsonObject object);
JsonObject postParam = new JsonObject();
postParam.addProperty("PersonaCedula", item.getPersonaCedula());
언급URL : https://stackoverflow.com/questions/21398598/how-to-post-raw-whole-json-in-the-body-of-a-retrofit-request
'bestsource' 카테고리의 다른 글
| Ruby on Rails와 함께 "MySQL 서버가 사라졌습니다" (0) | 2023.08.02 |
|---|---|
| 디버거가 내 ASP의 중단점에서 중지되지 않는 이유는 무엇입니까?NET 어플리케이션? (0) | 2023.08.02 |
| base 64 각도의 문자열 인코딩 및 디코딩(2+) (0) | 2023.07.28 |
| Oracle에 대한 EF 쿼리가 "ORA-12704: 문자 집합 불일치"를 발생시킵니다. (0) | 2023.07.28 |
| 어떻게 메모리를 할당하고 (포인터 매개 변수를 통해) 호출 함수에 반환할 수 있습니까? (0) | 2023.07.28 |