Qual è la struttura/modello per android/java per organizzare le chiamate al servizio web http nel progetto?

Question

In questo momento ogni volta che il mio progetto ha un servizio web sul back-end. Sono abituato a creare il mio progetto con questa struttura/modello.

Progetto

• HttpMethods pacchetto
  • HttpGetThread
    
  • HttpPostThread
    
  • HttpMultipartPostThread
• Interfacce pacchetto
  • IPostResponse

Il codice che ho scritto nelle mie questi file Java sono,

IPostResponse.java

public interface IPostResponse { 
    public void getResponse(String response); 
} 

HttpGetThread.java

public class HttpGetThread extends Thread { 

    private String url; 
    private final int HTTP_OK = 200; 
    private IPostResponse ipostObj; 

    public HttpGetThread(String url, IPostResponse ipostObj) { 
     this.url = url; 
     this.ipostObj = ipostObj; 
    } 

    public void run() { 
     try { 
      HttpClient httpClient = new DefaultHttpClient(); 
      HttpGet httpGet = new HttpGet(url); 
      HttpResponse httpResponse = httpClient.execute(httpGet); 
      int responseCode = httpResponse.getStatusLine().getStatusCode(); 
      if (responseCode == HTTP_OK) { 
       InputStream inputStream = httpResponse.getEntity().getContent(); 
       int bufferCount = 0; 
       StringBuffer buffer = new StringBuffer(); 
       while ((bufferCount = inputStream.read()) != -1) { 
        buffer.append((char) bufferCount); 
       } 
       ipostObj.getResponse(buffer.toString()); 
      } 
     } catch (ClientProtocolException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

Stesso modo nelle classi HttpPost e HttpMultipartPost estendendo Thread e avendo un costruttore e un metodo di esecuzione.

Poi,

a implementare l'interfaccia un'attività estendo che l'attività principale a tutte le altre attività e per ottenere la risposta e fare chiamate creando oggetto di classi HTTP con parametri e chiamo obj.start();

---

Continuo a credere che: mi mancano molte cose o questa struttura è molto povera.

ho bisogno di sapere che, per un'applicazione Android per implementare Web Service chiama per lo più tutte le attività e di avere il codice riusabilità quale modello/struttura devo seguire?

Ho appena visto come Facebook chiama il servizio web, ad esempio Login/Logout ha gli ascoltatori Login e Logout.

C'è qualche blog/articolo/risposte che è ben documentato per lo stesso? Per favore, qualche utente può condividere la sua eccellente esperienza e soluzione per lo stesso?

io sono più interessato a "Come devono mia classe e interfaccia simile, che tipo di metodi dovrebbe avere?"

Answer 1

1 ° e per la maggior parte suggerimento è perché non si utilizza Painless Threading cioè AsyncTask

Ora la seconda cosa crea un codice riutilizzabile come di seguito, è possibile creare tanti metodi con i parametri di richiesta.

public class JSONUtil { 

    private static JSONUtil inst; 

    private JSONUtil() { 

    } 

    public static JSONUtil getInstance() { 
     if (inst == null) 
      inst = new JSONUtil(); 
     return inst; 
    } 

    /** 
    * Request JSON based web service to get response 
    * 
    * @param url 
    *   - base URL 
    * @param request 
    *   - JSON request 
    * @return response 
    * @throws ClientProtocolException 
    * @throws IOException 
    * @throws IllegalStateException 
    * @throws JSONException 
    */ 
    public HttpResponse request(String url, JSONObject request) 
      throws ClientProtocolException, IOException, IllegalStateException, 
      JSONException { 

     synchronized (inst) { 

      DefaultHttpClient client = new DefaultHttpClient(); 
      HttpPost post = new HttpPost(url); 
      post.setEntity(new StringEntity(request.toString(), "utf-8")); 
      HttpResponse response = client.execute(post); 
      return response; 
     } 
    } 

    public HttpResponse request(String url) 
      throws ClientProtocolException, IOException, IllegalStateException, 
      JSONException { 

     synchronized (inst) { 

      DefaultHttpClient client = new DefaultHttpClient();    
      HttpPost post = new HttpPost(url); 
      post.addHeader("Cache-Control", "no-cache"); 
      HttpResponse response = client.execute(post); 
      return response; 
     } 
    } 
} 

Answer 2

Google up il più popolare framework MVC Android e utilizzare quello.

MVC pattern on Android

Answer 3

So che questa è una vecchia questione, ma ancora, vorrei rispondere a condividere quello che ho fatto sui miei progetti e mi amerà i suggerimenti da parte della comunità sul mio approccio.

HttpClient

Se si prende un'occhiata a HttpClient (come entità per fare la richiesta agli endpoint), è tutto su richiesta e risposta. Pensa in questo modo. Il comportamento del protocollo Http per "invio di richiesta" richiede il metodo, le intestazioni (facoltativo), il corpo (facoltativo). Allo stesso modo, in cambio della richiesta, otteniamo la risposta con il codice di stato, le intestazioni e il corpo. Così si può semplicemente avere il vostro HttpClient come:

public class HttpClient 
{ 
    ExecutorService executor = Executors.newFixedThreadPool(5); 
    //method below is just prototype 
    public String execute(String method, String url, Map < String, String > headers) 
    { 
      try 
      { 
      URL url = new URL("http://www.javatpoint.com/java-tutorial"); 
      HttpURLConnection huc = (HttpURLConnection) url.openConnection(); 
      //code to write headers, body if any 
      huc.disconnect(); 
      //return data 
      } 
      catch (Exception e) 
      { 
      System.out.println(e); 
      } 
    } 

     public String executeAsync(String method, String url, Map < String, String > headers, Callback callback) 
    {//Callback is Interface having onResult() 
     executor.execute(
      new Runnable() 
      { 
       void run() 
       { 
        String json= execute(method,url,headers) 
        callback.onResult(json); 
       } 
      } 
     ); 
    } 
} 

In questo modo non c'è bisogno di creare una classe per la richiesta separata. Invece, utilizzeremo semplicemente lo HtttpClient. Devi chiamare l'API su altro thread (non sul thread principale di Android).

API Struttura

Diciamo che avete risorsa chiamata per l'utente ed è necessario CRUD nella vostra applicazione. È possibile creare UserRepository interfaccia e implementazione UserRepositoryImpl

interface UserRepository 
{ 
    void get(int userId, Callback callback); 

    void add(String json,Callback callback); 

    //other methods 
} 


class UserRepositoryImp 
{ 
    void get(int userId, Callback callback) 
    { 
     HttpClient httpClient= new HttpClient(); 
     //create headers map 
     httpClient.executeAsync("GET","/",authHeaders,callback); 
    } 

    void add(String json,Callback callback) 
    { 
     HttpClient httpClient= new HttpClient(); 
     //create headers map 
     httpClient.executeAsync("POST","/",authHeaders,callback); 
    } 

    //other methods 
} 

Si prega di prendere nota che è necessario aggiornare UI sul thread dell'interfaccia utente di Android. [Sopra attuazione non ti preoccupare che]