Good design patterns for coding many HTTP requests

问题:

In my app, i have lots of GET,POST, PUT requests. Right now, i have a singleton class that holds my downloaded data and has many inner classes that extend AsyncTask. In my singleton class, i have also a few interfaces like this:

/**
* Handlers for notifying listeners when data is downloaded
* 
*/
public interface OnQuestionsLoadedListener {

    public void onDataLoadComplete();

    public void onDataLoadingError();       
}

Is there something wrong with this pattern (many inner classes that extend AsyncTask)? Could it be done more efficiently with maybe just 1 inner class for every HTTP call (1 for GET, 1 for POST, ...)? If so, how to decide what to do after e.g. GET request?

回答1:

As a whole, you should get away from AsyncTasks while preforming network requests.

Your AsyncTasks are linked to your Activity. That means, if your Activity stops, your AsyncTask stops. This isn't the biggest problem when fetching data to show in that Activity, since you won't care that the fetching has stopped. But when you want to send some saved data to the server, and your user pressed 'back' or something like that before everything is sent, the data could be lost and not send.

What you want to have instead, is a Service which will keep running regardless of what happens to your Activities.

I'd advise you to take a look into RoboSpice. Even if you decide not to use it, reading what it does and why it does will give you a good insight on the pretty long list of reasons not to use AsyncTasks for network requests and why better to use Services. If you use this, the rest of your question about efficiently network requesting is obsolete too, since they'll handle it for you the best way possible.

回答2:

Nothing wrong with many async classes.

What ido is have a network layer,a service class. Send an intent to the service class with a resultreceiver object as part of intent. then in the service make http request in async task and send back the the result through result receiver object.

A good design is to abstract the ui (activity or fragment) from network access.

回答3:

In a recently developed app I followed a similar scheme but in addition implemented a WebRequest class doing the actual GET, POST, PUT etc.

What I now have is a "Connector" class which has a whole lot of AsyncTask subclasses within. In my implementation, however, I made them accept a Callback object to which each of those subclasses passes the Http result.

I think this is a valid if perhaps not ideal way.

What I imagine could be an improvement would be if I had just one subclass of Asynctask to which I would pass the request body (which is now built within those different tasks), the request url and method as well as the callback (which is, in my opinion a rather nice way to get the results).