Volley

配置

jar包http://pan.baidu.com/s/1eRRF9Fs

创建application

public class MyApplication extends Application {
public static RequestQueue queue;
@Override
public void onCreate() {
super.onCreate();
queue = Volley.newRequestQueue(getApplicationContext());
}

public static RequestQueue getHttpQueue() {
return queue;
}
}

<application
android:name=".MyApplication"
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>

1.发送请求(get为例)

private void volleyGet() {
String url = "http://192.168.206.41:6060/index.php?r=user/post-test";
StringRequest request = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {
@Override
public void onResponse(String s) {
Log.e(TAG, "onResponse: " + s);
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError volleyError) {
Log.e(TAG, "onErrorResponse: " + volleyError.getMessage());
}
});
request.setTag("get");
MyApplication.getHttpQueue().add(request);
}

2.生命周期联动

@Override
protected void onStop() {
super.onStop();
MyApplication.getHttpQueue().cancelAll("get");
}

3.加载图片

private void loadImageByVolley() {
String url = "http://pic20.nipic.com/20120409/9188247_091601398179_2.jpg";
ImageRequest request = new ImageRequest(url,new Listener<Bitmap>() {
@Override
public void onResponse(Bitmap bitmap) {
image.setImageBitmap(bitmap);
}
},
0, 0, Config.RGB_565,
new ErrorListener() {
@Override
public void onErrorResponse(VolleyError volleyError) {
image.setImageResource(R.mipmap.ic_launcher);
}
});
request.setTag("loadImage");
MyApplication.getHttpQueues().add(request);
}

4.缓存图片

private void loadImageWithCache() {
String url = "http://pic20.nipic.com/20120409/9188247_091601398179_2.jpg";
ImageLoader loader = new ImageLoader(MyApplication.getHttpQueues(), new BitmapCache());
ImageListener listener = loader.getImageListener(image,R.mipmap.ic_launcher,R.mipmap.ic_launcher);
loader.get(url,listener);
}

public class BitmapCache implements ImageLoader.ImageCache{
//LruCache是基于内存的缓存类
private LruCache<String,Bitmap> lruCache;
//LruCache的最大缓存大小
private int max = 10 * 1024 * 1024;
public BitmapCache() {
lruCache = new LruCache<String, Bitmap>(max){
@Override
//缓存图片的大小
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight();
}
};
}

@Override
public Bitmap getBitmap(String s) {
return lruCache.get(s);
}

@Override
public void putBitmap(String s, Bitmap bitmap) {
lruCache.put(s,bitmap);
}
}

5.自带组件NetworkImageView

注意点

1.NetworkImageView并不需要提供任何设置最大宽高的方法也能够对加载的图片进行压缩。

2.如果你不想对图片进行压缩的话，只需要在布局文件中把NetworkImageView的layout_width和layout_height都设置成wrap_content

networkImageView.setDefaultImageResId(R.drawable.default_image);
networkImageView.setErrorImageResId(R.drawable.failed_image);
networkImageView.setImageUrl("http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg"， imageLoader);

6.自定义请求（XML/Gson）

public class XMLRequest extends Request<XmlPullParser> {

private final Listener<XmlPullParser> mListener;

public XMLRequest(int method, String url, Listener<XmlPullParser> listener,
ErrorListener errorListener) {
super(method, url, errorListener);
mListener = listener;
}

public XMLRequest(String url, Listener<XmlPullParser> listener, ErrorListener errorListener) {
this(Method.GET, url, listener, errorListener);
}

@Override
protected Response<XmlPullParser> parseNetworkResponse(NetworkResponse response) {
try {
String xmlString = new String(response.data,
HttpHeaderParser.parseCharset(response.headers));
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser xmlPullParser = factory.newPullParser();
xmlPullParser.setInput(new StringReader(xmlString));
return Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
} catch (XmlPullParserException e) {
return Response.error(new ParseError(e));
}
}

@Override
protected void deliverResponse(XmlPullParser response) {
mListener.onResponse(response);
}
}

public class GsonRequest<T> extends Request<T> {

private final Listener<T> mListener;

private Gson mGson;

private Class<T> mClass;

public GsonRequest(int method, String url, Class<T> clazz, Listener<T> listener,
ErrorListener errorListener) {
super(method, url, errorListener);
mGson = new Gson();
mClass = clazz;
mListener = listener;
}

public GsonRequest(String url, Class<T> clazz, Listener<T> listener,
ErrorListener errorListener) {
this(Method.GET, url, clazz, listener, errorListener);
}

@Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
try {

b101
String jsonString = new String(response.data,
HttpHeaderParser.parseCharset(response.headers));
return Response.success(mGson.fromJson(jsonString, mClass),
HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
}
}

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

7.二次封装好处

1）统一请求成功和失败的提示信息

2）统一控制请求的头信息（编码，表单提交方式）

8.深入理解

1）HTTP请求的使用，在Android 2.3及以上版本，使用的是HttpURLConnection，而在Android 2.2及以下版本，使用的是HttpClient。参考http://blog.csdn.net/guolin_blog/article/details/12452307

结论：在Android 2.2版本之前，HttpClient拥有较少的bug，因此使用它是最好的选择。

而在Android 2.3版本及以后，HttpURLConnection则是最佳的选择。它的API简单，体积较小，因而非常适用于Android项目。压缩和缓存机制可以有效地减少网络访问的流量，在提升速度和省电方面也起到了较大的作用。对于新的应用程序应该更加偏向于使用HttpURLConnection，因为在以后的工作当中我们也会将更多的时间放在优化HttpURLConnection上面。

注意点：HttpURLConnection一个可读的InputStream调用close()方法时，就有可能会导致连接池失效。反射的方式来启动响应缓存功能支持4.0之前和之后。

2）调用了Volley.newRequestQueue(context)之后，就会有五个线程一直在后台运行，不断等待网络请求的到来，其中CacheDispatcher是缓存线程，NetworkDispatcher是网络请求线程。

3）默认情况下如果系统版本号大于9就创建的HurlStack对象，否则创建HttpClientStack对象。前面已经说过，这两个对象的内部实际就是分别使用HttpURLConnection和HttpClient来发送网络请求的。

4）我们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，如果发现可以找到相应的缓存结果就直接读取缓存并解析，然后回调给主线程。如果在缓存中没有找到结果，则将这条请求加入到网络请求队列中，然后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。