Android GSON использовать метод POST

Question

У меня есть следующий файл PostActivity.java, который успешно получает данные с сервера PHP с использованием метода.GET, однако мне нужно изменить метод GSON, чтобы использовать Method.POST вместо метода .get, так что я могу отправить два параметра (операции и пользователей (ИДП)) на сервер, как показано ниже:

{ 
    "operation":"listApps", 
    "user":{ 
     "pid":"1" 
    } 
} 

PostActivity.java

import android.app.Activity; 
import android.os.Bundle; 
import android.util.Log; 
import android.widget.ArrayAdapter; 
import android.widget.ListView; 

import com.android.volley.Request; 
import com.android.volley.RequestQueue; 
import com.android.volley.Response; 
import com.android.volley.VolleyError; 
import com.android.volley.toolbox.StringRequest; 
import com.android.volley.toolbox.Volley; 
import com.google.gson.Gson; 
import com.google.gson.GsonBuilder; 

import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 

public class PostActivity extends Activity { 

    private static final String ENDPOINT = "http://www.locahost.com/api"; 

    private RequestQueue requestQueue; 
    private Gson gson; 
    private List<String> posts_strs ; 

    private List<Post> posts ; 

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

     requestQueue = Volley.newRequestQueue(getApplicationContext()); 
     GsonBuilder gsonBuilder = new GsonBuilder(); 
     gsonBuilder.setDateFormat("M/d/yy hh:mm a"); 
     gson = gsonBuilder.create(); 

     posts_strs = new ArrayList<String>(); 

     fetchPosts(); 
    } 

    private void fetchPosts() { 
     StringRequest request = new StringRequest(Request.Method.GET, ENDPOINT, onPostsLoaded, onPostsError); 

     requestQueue.add(request); 
    } 

    private final Response.Listener<String> onPostsLoaded = new Response.Listener<String>() { 
     @Override 
     public void onResponse(String response) { 

      posts = Arrays.asList(gson.fromJson(response, Post[].class)); 

      ListView listview = (ListView) findViewById(R.id.postListView); 

      for (Post post : posts) { 
       posts_strs.add(post.ID + ": " + post.title); 
      } 
      ArrayAdapter<String> adapter = new ArrayAdapter<String>(PostActivity.this,R.layout.single_post_item,R.id.textView, posts_strs); 

      listview.setAdapter(adapter); 

     } 
    }; 

    private final Response.ErrorListener onPostsError = new Response.ErrorListener() { 
     @Override 
     public void onErrorResponse(VolleyError error) { 
      Log.e(PostActivity.class.getSimpleName(), error.toString()); 
     } 
    }; 
} 

Answer 1

Вы должны обновить StringRequest экземпляр fetchPosts метод:

StringRequest request = new StringRequest(Request.Method.POST, ENDPOINT, onPostsLoaded, onPostsError) {  

    @Override 
    protected Map<String, String> getParams() { 
     Map<String, String> params = new HashMap<String, String>(); 
     params.put("operation", "listApps"); 

     // Create a POJO matching user structure and serialize this object to JSON to send it 
     params.put("user", "String matching format you want to send"); 

     return params; 
    } 
}; 

Answer 2

вы можете использовать следующий код, чтобы отправить объект (класс Java), и вернуть объект (класс) и почтовые данные в формате JSON с API

public class JsonRequest<T> extends Request<T> { 
     private static final String TAG = "JsonRequestHelper"; 
     private final Gson gson = new Gson(); 
     private final Class<T> returnType; 
     private final Object model; 
     private final Map<String, String> headers; 
     private final Response.Listener<T> listener; 

     /** 
     * Make a GET request and return a parsed object from JSON. 
     * 
     * @param url  URL of the request to make 
     * @param returnType Relevant class object, for Gson's reflection 
     * @param headers Map of request headers 
     */ 
     public JsonRequest(Integer httpVerb, String url, Class<T> returnType, Object model, Map<String, String> headers, 
          Response.Listener<T> listener, Response.ErrorListener errorListener) { 
      super(httpVerb, url, errorListener); 
      this.returnType = returnType; 
      this.model = model; 
      this.headers = headers; 
      this.listener = listener; 
     } 

     @Override 
     public Map<String, String> getHeaders() throws AuthFailureError { 
      return headers != null ? headers : super.getHeaders(); 
     } 

     public static Map<String, String> getMapFromEntity(Object entity) { 
      try { 
       Map<String, String> map = new HashMap<String, String>(); 
       Field[] fields = entity.getClass().getFields(); 
       for (Field f : fields) 
        if (f != null && f.getModifiers() == Modifier.PUBLIC) 
         map.put(f.getName(), f.get(entity).toString()); 
       return map; 
      } catch (IllegalAccessException error) { 
       Log.e(TAG, error.getMessage()); 
       return null; 
      } 
     } 

     @Override 
     protected void deliverResponse(T response) { 
      listener.onResponse(response); 
     } 

     @Override 
     public String getBodyContentType() { 
      return "application/json; charset=utf-8"; 
     } 

     @Override 
     public byte[] getBody() { 
      return gson.toJson(this.model).getBytes(); 
     } 

     @Override 
     protected Response<T> parseNetworkResponse(NetworkResponse response) { 
      try { 
       String json = new String(
         response.data, 
         HttpHeaderParser.parseCharset(response.headers)); 
       return Response.success(
         gson.fromJson(json, returnType), 
         HttpHeaderParser.parseCacheHeaders(response)); 
      } catch (UnsupportedEncodingException e) { 
       return Response.error(new ParseError(e)); 
      } catch (JsonSyntaxException e) { 
       return Response.error(new ParseError(e)); 
      } 
     } 
    }