Android中网络请求框架

概述

在实际开发中，频繁的接触网络请求，而网络请求的方式很多，最常见的也就那么几个。本篇文章对常见的网络请求库进行一个总结，说说网络请求到底哪家强。

一般网络请求专指 http请求，在选择一个框架之前，尽量选择比较专注于一项功能的库，不选大而全的库，其实在软件设计领域有一个原则叫做「单一职责原则」一个库能把一件事做好就很不错了。在上面原则的基础上，所以目前来说单纯的网络请求库就锁定在了 Volley、OkHttp、Retrofit 三个，android-async-http 的作者已经不维护，所以这里就不多说了。

使用过程中不要忘记添加网络访问权限

<uses-permission android:name="android.permission.INTERNET"

在 Android 开发中是可以直接使用现成的 api 进行网络请求的，就是使用 HttpClient、HttpUrlConnection 进行操作，目前 HttpClient 已经被废弃，而 android-async-http 是基于 HttpClient 的，我想可能也是因为这个原因作者放弃维护。我们下面先依次介绍这三种。

HttpClient

特点

高效稳定，但是维护成本高昂，故android 开发团队不愿意在维护该库而是转投更为轻便的HttpUrlConnection

用法

HttpClient是一个接口，因此无法直接创建它的实例，一般都是创建一个DefaultHttpClient实例
如果要发起Get请求，需要创建一个HttpGet对象，并传入请求地址
如果要发起Post请求，需要创建一个HttpPost对象。并传入请求地址，通过setEntity函数设置请求参数
调用execute方法，传入HttpGet或者HttpPost实例，执行后返回HttpResponse对象，判断响应状态码
解析响应结果，通过调用getEntity函数获得一个HttpEntity对象，之后可以通过EntityUtils.toString方法将其转换为字符串

由于在android2.3之后就被HttpUrlConnection取代了，这里也不过多介绍了，不过当初学习它的时候还没接触到其他库，就感觉它好方便，下面简单贴出使用方法:

GET

private String get(String url){
    HttpClient client=null;
    HttpGet request=null;
    try {
         client=new DefaultHttpClient();
         request=new HttpGet(url);
         HttpResponse response=client.execute(request);
         if(response.getStatusLine().getStatusCode()== HttpStatus.SC_OK) {
              String result=EntityUtils.toString(response.getEntity(),"UTF-8");
              return result;
         }
     } catch (IOException e) {
            e.printStackTrace();
     }
     return  null;
}

POST

private String post(String url,List<NameValuePair> params){
    HttpClient client=null;
    HttpPost request=null;
    try {
        client=new DefaultHttpClient();
        request=new HttpPost(url);
        request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
        HttpResponse response=client.execute(request);
        if(response.getStatusLine().getStatusCode()== HttpStatus.SC_OK){
             String result=EntityUtils.toString(response.getEntity(),"UTF-8");
             return result;
        }
    } catch (IOException e) {
           e.printStackTrace();
    }
    return  null;
}

HttpUrlConnection

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

特点

比较轻便，灵活，易于扩展
在3.0后以及4.0中都进行了改善，如对HTTPS的支持
在4.0中，还增加了对缓存的支持

用法

首先我们需要获取到一个HttpURLConnection实例，一般需要new出一个URL对象，并传入目标网络地址，通过调用openConnection()方法获得HttpURLConnection实例。
得到该实例后。我们需要设置一下http请求的的方法，这里我们主要研究get和post，默认是使用get方法。get一般用于从服务器获取数据，post一般用于向服务器提交数据，设置请求方法使用函数setRequestMethod(“POST”)进行设置。
此外可以进行一些请求的限制，比如连接超时的时间等，可以通过setConnectTimeout设置超时时间。
获取服务器返回的输入流，使用getInputStream方法获取。
读取内容并处理
关闭连接，通过调用disconnect方法关闭当前的连接。

GET

public String get(String urlPath) {
        HttpURLConnection connection = null;
        InputStream is = null;
        try {
            URL url = new URL(urlPath); // 获得URL对象
            connection = (HttpURLConnection) url.openConnection(); // 获得HttpURLConnection对象
            connection.setRequestMethod("GET"); // 默认为GET
            connection.setUseCaches(false); // 不使用缓存
            connection.setConnectTimeout(10000); // 设置超时时间
            connection.setReadTimeout(10000); // 设置读取超时时间
            connection.setDoInput(true); // 设置是否从httpUrlConnection读入，默认情况下是true;
            if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                // 相应码是否为200
                is = connection.getInputStream(); // 获得输入流
                BufferedReader reader = new BufferedReader(new InputStreamReader(is)); // 包装字节流为字符流
                StringBuilder response = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                return response.toString();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
                connection = null;
            }
            if (is != null) {
                try {
                    is.close();
                    is = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
}

POST

private String post(String urlPath, Map<String, String> params) {
        if (params == null || params.size() == 0) {
            return get(urlPath); // 变成get请求
        }
        OutputStream os = null;
        InputStream is = null;
        HttpURLConnection connection = null;
        StringBuffer body = getParamString(params);
        byte[] data = body.toString().getBytes();
        try {
            URL url = new URL(urlPath); //获得URL对象
            connection = (HttpURLConnection) url.openConnection(); //获得HttpURLConnection对象
            connection.setRequestMethod("POST"); // 设置请求方法为post
            connection.setUseCaches(false); //不使用缓存
            connection.setConnectTimeout(10000); //设置超时时间
            connection.setReadTimeout(10000); //设置读取超时时间
            connection.setDoInput(true); //设置是否从httpUrlConnection读入，默认情况下是true;
            connection.setDoOutput(true); //设置为true后才能写入参数（必须的）
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Content-Length", String.valueOf(data.length));
            os = connection.getOutputStream();
            os.write(data); //写入Post请求参数
            if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                //相应码是否为200
                is = connection.getInputStream(); //获得输入流
                BufferedReader reader = new BufferedReader(new InputStreamReader(is)); //包装字节流为字符流
                StringBuilder response = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                return response.toString();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                connection.disconnect();
                connection = null;
            }
        }
        return null;
    }
    private StringBuffer getParamString(Map<String, String> params) {
        StringBuffer result = new StringBuffer();
        Iterator<Map.Entry<String, String>> iterator = params.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> param = iterator.next();
            String key = param.getKey();
            String value = param.getValue();
            result.append(key).append('=').append(value);
            if (iterator.hasNext()) {
                result.append('&');
            }
        }
        return result;
 }

android-async-http

Github & 官网

android-async-http是基于Http Client的，但是呢在安卓中Http Client已经废弃了，所以也不建议使用这个库了。然后仍然有一些可取的内容值得学习，所以这里也介绍一下。

特点

所以请求在子线程中完成，请求回调在调用该请求的线程中完成
使用线程池
使用RequestParams类封装请求参数
支持文件上传
持久化cookie到SharedPreferences，个人感觉这一点也是这个库的重要特点，可以很方便的完成一些模拟登录
支持json
支持HTTP Basic Auth

用法

编写一个静态的HttpClient

public class TestClient {

private static final String BASE_URL = "http://121.41.119.107/";
private static AsyncHttpClient client = new AsyncHttpClient();

public static void get(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {
    client.get(getAbsoluteUrl(url), params, responseHandler);
}
public static void post(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {
    client.post(getAbsoluteUrl(url), params, responseHandler);
}
private static String getAbsoluteUrl(String relativeUrl) {
    return BASE_URL + relativeUrl;
}

}

调用get或者post方法

参数通过RequestParams传递，没有参数则传递null

RequestParams  params = new RequestParams();
params.put("","");

如果要保存cookie，在发起请求之前调用以下代码

PersistentCookieStore myCookieStore = new PersistentCookieStore(this);
client.setCookieStore(myCookieStore);

之后请求所得到的cookie都会自动持久化

如果要自己添加cookie，则调用以下代码

BasicClientCookie newCookie = new BasicClientCookie("cookiesare", "awesome");
newCookie.setVersion(1);
newCookie.setDomain("mydomain.com");
newCookie.setPath("/");
myCookieStore.addCookie(newCookie);

使用

在回调函数中处理返回结果

private void get(){
        TestClient.get("test/index.php", null, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
            }
            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
            }
        });
    }
    private void post(){
        RequestParams params = new RequestParams();
        params.put("user","asas");
        params.put("pass","12121");
        params.put("time","1212121");
        TestClient.post("test/login.php", params, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
            }
            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
            }
        });
}

Volley

Github & 官网 & 源码解析

Google推出的异步网络请求框架和图片加载框架，该框架封装的扩展性很强，支持 HttpClient、HttpUrlConnection，甚至支持 OkHttp。Volley 里面也封装了 ImageLoader ，所以如果你愿意你甚至不需要使用图片加载框架，不过这块功能没有一些专门的图片加载框架强大，对于简单的需求可以使用，对于稍复杂点的需求还是需要用到专门的图片加载框架。

既然在android2.2之后不建议使用Http Client，那么有没有一个库是android2.2及以下版本使用Http Client，而android2.3及以上版本使用HttpUrlConnection的呢，答案是肯定的，就是Volley。

Volley可以说是把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。除了简单易用之外，Volley在性能方面也进行了大幅度的调整，它的设计目标就是非常适合去进行数据量不大，但通信频繁的网络操作，而对于大数据量的网络操作，比如说下载文件等，Volley的表现就会非常糟糕
Volley提供了JsonObjectRequest JsonArrayRequest StringRequest ImageRequest NetworkImageView 等Request形式。

特点

Volley的优势在于处理小文件的http请求
特别适合数据量小，通信频繁的网络操作。android绝大多数都属于这种类型。
不支持 post 大数据，所以不适合上传文件
在Volley中也是可以使用Okhttp作为传输层
Volley在处理高分辨率的图像压缩上有很好的支持
NetworkImageView在GC的使用模式上更加保守，在请求清理上也更加积极，networkimageview仅仅依赖于强大的内存引用，并当一个新请求是来自ImageView或ImageView离开屏幕时便会清理掉所有的请求数据
基于接口设计, 扩展性强
一定程度上符合http规范

返回包括ResponseCode 的处理，请求头的处理，缓存机制的支持
重试以及优先级的定义
提供简单的图片加载工具

用法

创建一个RequestQueue对象
创建一个Request对象
将Request对象添加到RequestQueue里面

GET

private void get(){
        RequestQueue queue= Volley.newRequestQueue(getApplicationContext());
        String url="http://121.41.119.107/test/index.php";
        StringRequest request=new StringRequest(url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                Log.d("TAG",response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
        });
        queue.add(request);
}

POST

通过指定请求方法为Request.Method.POST使其成为post请求，然后重新getParams方法设置请求参数。当发出POST请求的时候，Volley会尝试调用StringRequest的父类——Request中的getParams()方法来获取POST参数

private void post() {
        RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
        String url = "http://121.41.119.107/test/login.php";
        StringRequest request = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                Log.d("TAG", response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
        }) {
            // 重写getParams方法设置参数
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                Map<String, String> params = new HashMap<String, String>();
                params.put("user", "asas");
                params.put("pass", "12121");
                params.put("time", "1212121");
                return params;
            }
        };
        queue.add(request);
}

加载图片

加载图像的方法和前面类似，只不过不在是StringRequest而是ImageRequest

private void getImage() {
        RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
        String url = "https://www.baidu.com/img/bdlogo.png";
        //第3第4个参数分别用于指定允许图片最大的宽度和高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，指定成0的话就表示不管图片有多大，都**不会进行压缩**
        //第五个参数就是ImageView里中的属性ScaleType
        //第六个参数用于指定图片的颜色属性
        ImageRequest request = new ImageRequest(url, new Response.Listener<Bitmap>() {
            @Override
            public void onResponse(Bitmap response) {
                ImageView iv= (ImageView) findViewById(R.id.iv);
                iv.setImageBitmap(response);
            }
        }, 0, 0, ImageView.ScaleType.CENTER, Bitmap.Config.ARGB_8888, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
     });
     queue.add(request);
}

其实加载图片的功能还远远不止这些，使用ImageLoader可以实现对图片的缓存，还可以过滤重复链接，避免发送重复的请求

ImageLoader的使用方法概括为以下几步:

创建一个RequestQueue对象
创建一个ImageLoader对象
获取一个ImageListener对象

调用ImageLoader的get()方法加载网络上的图片

//继承ImageCache，使用LruCache实现缓存
public class BitmapCache implements ImageLoader.ImageCache {

    private LruCache<String, Bitmap> mCache;
    public BitmapCache() {
        int maxSize = 10 * 1024 * 1024;
        mCache = new LruCache<String, Bitmap>(maxSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getRowBytes() * bitmap.getHeight();
            }
        };
    }
    @Override
    public Bitmap getBitmap(String url) {
        return mCache.get(url);
    }
    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        mCache.put(url, bitmap);
    }
}
private void getImageByImageLoader() {
    ImageView iv= (ImageView) findViewById(R.id.iv);
    RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
    String url = "https://www.baidu.com/img/bdlogo.png";
    ImageLoader loader=new ImageLoader(queue,new BitmapCache());
    // 第一个参数指定用于显示图片的ImageView控件
    // 第二个参数指定加载图片的过程中显示的图片
    // 第三个参数指定加载图片失败的情况下显示的图片
    ImageLoader.ImageListener listener=ImageLoader.getImageListener(iv,R.mipmap.ic_launcher,R.mipmap.ic_launcher);
    // 调用ImageLoader的get()方法来加载图片
    // 第一个参数就是图片的URL地址
    // 第二个参数则是刚刚获取到的ImageListener对象
    // 如果想对图片的大小进行限制，也可以使用get()方法的重载，指定图片允许的最大宽度和高度，即通过第三第四个参数指定
    loader.get(url,listener);

}

最后，Volley提供了一种自定义ImageView来加载图片，其使用方法可概括为 :

创建一个RequestQueue对象
创建一个ImageLoader对象
在布局文件中添加一个NetworkImageView控件
在代码中获取该控件的实例
设置要加载的图片地址

我们在布局中申明该控件

<com.android.volley.toolbox.NetworkImageView
        android:id="@+id/network_image_view"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"/>

在程序中实现加载

public void networkImageView(){
        RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
        ImageLoader loader=new ImageLoader(queue,new BitmapCache() );
        NetworkImageView niv = (NetworkImageView) findViewById(R.id.network_image_view);
        niv.setDefaultImageResId(R.mipmap.ic_launcher);//设置加载中显示的图片
        niv.setErrorImageResId(R.mipmap.ic_launcher);//设置加载失败时显示的图片
        niv.setImageUrl("https://www.baidu.com/img/bdlogo.png",  loader);//设置目标图片的URL地址
}

自定义Request

在实际应用中，往往需要将http请求与json进行集成，而Volley正恰恰支持这样的方式，不过需要我们自己自定义Request，这里我们使用google的Gson库进行集成。

继承Request类
重写parseNetworkResponse，实现json与实体类转换，由于实体类未定，所以采用泛型

下文用到的json字符串如下:

{"name":"lizhangqu","age":16}

public class GsonRequest<T> extends Request<T> {
    private final Response.Listener<T> mListener;
    private Gson mGson;
    private Class<T> mClass;

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

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            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);
    }
}

编写测试实体类，两个字段一个name一个age

public class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

调用方法和StringRequest是一样的。如下所示:

private void json(){
        RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
        String url = "http://121.41.119.107/test/index.php";
        GsonRequest<Person> request=new GsonRequest<Person>(url, Person.class, new Response.Listener<Person>() {
            @Override
            public void onResponse(Person response) {
                Log.d("TAG",response.toString());
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
        });
        queue.add(request);
}

基本的使用方法
 直接返回Object的话，用Gson/FastJson与Volley的结合

OkHttp

Github & 官网 & 源码解析

OkHttp 是一个 Java 的 HTTP+SPDY 客户端开发包，同时也支持 Android。需要Android 2.3以上

OkHttp 是 Square 公司开源的针对 Java 和 Android 程序，封装的一个高性能 http 请求库，所以它的职责跟 HttpUrlConnection 是一样的，支持 spdy、http 2.0、websocket ，支持同步、异步，而且 OkHttp 又封装了线程池，封装了数据转换，封装了参数使用、错误处理等，api 使用起来更加方便。可以把它理解成是一个封装之后的类似 HttpUrlConnection 的一个东西，但是你在使用的时候仍然需要自己再做一层封装，这样才能像使用一个框架一样更加顺手。

特点

OKHttp是Android版Http客户端。非常高效，支持SPDY、连接池、GZIP和 HTTP 缓存。
默认情况下，OKHttp会自动处理常见的网络问题，像二次连接、SSL的握手问题。
如果你的应用程序中集成了OKHttp，Retrofit默认会使用OKHttp处理其他网络层请求。
从Android4.4开始HttpURLConnection的底层实现采用的是OkHttp
这个onResponse执行的线程并不是UI线程
Interceptor 云端响应拦截器，设置缓存策略
- 应用拦截器（ApplicationInterceptors）
  
  主要用于查看请求信息及返回信息，如链接地址、头信息、参数信息等
- 网络拦截器（Network Interceptors）
  
  可以添加、删除或替换请求头信息，还可以改变的请求携带的实体。

缓存的使用方式

noCache ：不使用缓存，全部走网络
noStore ： 不使用缓存，也不存储缓存
onlyIfCached ： 只使用缓存
maxAge ：设置最大失效时间，失效则不使用
maxStale ：设置最大失效时间，失效则不使用
minFresh ：设置最小有效时间，失效则不使用
FORCE_NETWORK ： 强制走网络
FORCE_CACHE ：强制走缓存

一般的get、post、基于http文件上传、文件下载、加载图片、支持请求回调、直接返回对象、对象集合、支持session的保持。
会从很多常用的连接问题中自动恢复。如果您的服务器配置了多个IP地址，当第一个IP连接失败的时候，OkHttp会自动尝试下一个IP。OkHttp还处理了代理服务器问题和SSL握手失败问题。

用法

新建一个OkHttpClient对象
通过Request.Builder对象新建一个Request对象
返回执行结果

GET

private String get(String url) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .build();
        Response response = null;
        try {
            response = client.newCall(request).execute();
            return response.body().string();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
}

POST

POST需要使用RequestBody对象，之后再构建Request对象时调用post函数将其传入即可

private String post(String url) {
        OkHttpClient client = new OkHttpClient();
        RequestBody formBody = new FormEncodingBuilder()
                .add("user", "Jurassic Park")
                .add("pass", "asasa")
                .add("time", "12132")
                .build();
        Request request = new Request.Builder()
                .url(url)
                .post(formBody)
                .build();
        Response response = null;
        try {
            response = client.newCall(request).execute();
            return response.body().string();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
}

此外，post的使用方法还支持文件等操作等

对Gson的支持

OkHttp还自带了对Gson的支持

private Person gson(String url){
        OkHttpClient client = new OkHttpClient();
        Gson gson = new Gson();
        Request request = new Request.Builder()
                .url(url)
                .build();
        Response response = null;
        try {
            response = client.newCall(request).execute();
            Person person = gson.fromJson(response.body().charStream(), Person.class);
            return person;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
}

异步操作

以上的两个例子必须在子线程中完成，同时okHttp还提供了异步的方法调用，通过使用回调来进行异步调用，然后OkHttp的回调依然不在主线程中，因此该回调中不能操作UI

private void getAsync(String url) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .build();
        Response response = null;
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Request request, IOException e) {
            }
            @Override
            public void onResponse(Response response) throws IOException {
                String result = response.body().string();
                Toast.makeText(getApplicationContext(),result,
Toast.LENGTH_SHORT).show();
                //不能操作ui，回调依然在子线程
                Log.d("TAG", result);
            }
        });
}

okHttp的使用还有很多内容，这里也不过多介绍，更多内容，参考官方网址

大牛张鸿洋版(有实现整合Gson)

完整的封装地址 & 使用手册

Retrofit

Github & 官网 & 源码解析

Retrofit 是 Square 公司出品的默认基于 OkHttp 封装的一套 RESTful 网络请求框架，RESTful 是目前流行的一套 api 设计的风格，并不是标准。Retrofit 的封装可以说是很强大，里面涉及到一堆的设计模式，你可以通过注解直接配置请求，你可以使用不同的 http 客户端，虽然默认是用 http ，可以使用不同 Json Converter 来序列化数据，同时提供对 RxJava 的支持，使用 Retrofit + OkHttp + RxJava + Dagger2 可以说是目前比较潮的一套框架，但是需要有比较高的门槛。

Retrofit 基于注解，提供JSON to POJO(Plain Ordinary Java Object简单Java对象)，POJO to JSON，网络请求(POST，GET,PUT，DELETE等)封装

特点

性能最好，处理最快
使用REST API时非常方便
传输层默认就使用OkHttp
支持NIO
拥有出色的API文档和社区支持
速度上比volley更快
如果你的应用程序中集成了OKHttp，Retrofit默认会使用OKHttp处理其他网络层请求
默认使用Gson

使用

Retrofit支持同步和异步两种方式，在使用时，需要将请求地址转换为接口，通过注解来指定请求方法，请求参数，请求头，返回值等信息。还是使用之前的person的那段json值，get请求到服务器后从数据库查询数据，返回值为查询到的数据，post请求向服务器提交一条数据，返回值为提交的数据。

首先完成请求所用的service，是一个interface，完全通过注解完成配置

public interface PersonService {

@Headers({
        "Cache-Control: max-age=640000",
        "User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko"
})
//通过注解设置请求头
@GET("/{test}/rest.php")
//设置请求方法为get，相对路径为注解内内容，其中{test}会被@Path注解指定内容替换
Person getPerson(@Path("test") String dir,@Query("name") String name);
//@Query用于指定参数
@FormUrlEncoded
//urlencode
@POST("/test/rest1.php")
//post提交
Person updatePerson(@Field("name") String name,@Field("age") int age);
//@Field提交的域
@POST("/test/rest1.php")
void updatePerson(@Field("name") String name,@Field("age") int age, Callback<Person> callback);
//异步回调，不能指定返回值

}

GET

使用时，通过RestAdapter的实例获得一个接口的实例，其本质是动态代理，注意含有返回值的方法是同步的，不能UI线程中调用，应该在子线程中完成

RestAdapter restAdapter = new RestAdapter.Builder()
```
.setEndpoint("http://121.41.119.107")
.build();
```
PersonService personService=restAdapter.create(PersonService.class);
Person person=personService.getPerson(“test”,”zhangsan”);
Log.d(“TAG”,person.toString());
POST

POST的调用同Get，获得adapter后获得一个代理对象，然后通过这个代理对象进行网络请求

Person person1=personService.updatePerson(“lizhangqu”, 12);
Log.d(“TAG”,person1.toString());
异步请求

如果要使用异步请求，需要将接口中的方法返回值修改会void，再加入回调参数Callback，就如PersonService中第三个方法一样，请求完成后会回调该callback对象的success或者fail方法。

RestAdapter restAdapter = new RestAdapter.Builder()
```
.setEndpoint("http://121.41.119.107")
.build();
```
PersonService personService=restAdapter.create(PersonService.class);
personService.updatePerson(“lizhangqu”,23, new Callback() {
```
@Override
public void success(Person person, Response response) {
    Log.d("TAG", person.toString());
}
@Override
public void failure(RetrofitError error) {
}
```
});

Retrofit的使用还有很多内容，下面提供官方网址(Retrofit已经更新到2.X版本，本文的使用方法为Retrofit1.x版本)

RoboSpice

RoboSpice：android异步网络库简单用法

NoHttp

参考

总结

网络请求库多种多样，最终其本质思想是一致的，要学会融汇贯通，还是要fucking the source code。

Square开源组合，用Retrofit(目前已经是2.0+) + OkHttp基本上已经可以处理任何业务场景了，Square开源库质量还是值得信赖。Retrofit的特点是简化了网络请求流程，同时自己内部对OkHtttp客户端做了封装，同时2.x把之前1.x版本的部分不恰当职责都转移给OkHttp了(例如Log，目前用OkHttp的Interceptor来实现)，这样的好处是职责清晰，Retrofit做自己该做的事。而且Retrofit提供不同的Json Converter实现（也可以自定义），同时提供RxJava支持(返回Observable对象)，配合Jackson(或者Gson)和RxJava，再加上Dagger2，效率大大提高。参见

Volley和android-async-http要用的话，也还是要做一下二次封装的。

推荐用最新的Android Flux来架构你的Android程序，Facebook提出的架构，文档比较全，数据流总是单向的飞。用过MVC，MVP，我还是是比较认同Flux的，而且之前公司用的架构模式跟Flux也比较像。AndroidFlux入门

volley, retrofit, android-async-http 帮你封装了具体的请求，线程切换以及数据转换。而OkHttp 是基于http协议封装的一套请求客户端，虽然它也可以开线程，但根本上它更偏向真正的请求，跟HttpClient, HttpUrlConnection的职责是一样的。所以不要混淆。

即使单纯使用OkHttp，还是会再包一层的，这样就等价于Volley之流的框架，只是封装的好与坏而已.

android-async-http已经比较老了，内部实现是基于HttpClient，想必你肯定知道6.0之后HttpClient是不是系统自带的了，不过它在最近的更新中将HttpClient的所有代码copy了一份进来，所以还能使用。

Volley是Google官方出的，Volley在设计的时候是将具体的请求客户端做了下封装：HurlStack，也就是说可以支持HttpUrlConnection, HttpClient, OkHttp，相当于模版模式吧，这样解耦还是非常方便的，可以随意切换，如果你之前使用过Volley，并习惯使用，那直接写个OkHttp扩展就行了。

Volley自己的定位是轻量级网络交互，适合大量的，小数据传输，如果你的项目比较大，那么目测还得把volley再次封装才会好用一些

Retrofit因为是Square出的，所以大家可能对它更崇拜些。Retrofit的跟Volley是一个套路，但解耦的更彻底: 比方说通过注解来配置请求参数，通过工厂来生成CallAdapter，Converter，你可以使用不同的请求适配器(CallAdapter), 比方说RxJava，Java8，Guava。你可以使用不同的反序列化工具(Converter)，比方说 json, protobuff, xml, moshi等等。
超级解耦，里面涉及到超多设计模式，个人觉得是很经典的学习案例。虽然支持Java8， Guava你可能也不需要用到。xml，protobuff等数据格式你也可能不需要解析。但是，万一遇到鬼了呢？

至于性能上，完全取决于请求客户端，也就是OkHttp的性能，跟这些封装工具没太大关系。

至于RxJava，最好充分理解其原理之后再使用，别人云亦云，特别team人数多的情况下，总得有个完全精通的吧，万一掉坑里了呢!

OkHttp是android平台最好的网络库，其是高性能的http库，支持同步、异步，而且实现了spdy、http2、websocket协议，api很简洁易用，和Volley一样实现了http协议的缓存。Picasso就是利用OkHttp的缓存机制实现其文件缓存，实现的很优雅，很正确，反例就是UIL（universal image loader），自己做的文件缓存，而且不遵守http缓存机制。Retrofit与Picasso一样都是在OkHttp基础之上做的封装，项目中可以直接用了

Volley是一个简单的异步http库，仅此而已。缺点是不支持同步，这点会限制开发模式；不能post大数据，所以不适合用来上传文件

android-async-http与volley一样是异步网络库，但Volley是封装的HttpUrlConnection，它是封装的HttpClient，而android平台不推荐用HttpClient了，所以这个库已经不适合android平台了

android-async-http使用了nio的方式实现的。OkHttp没有提供nio selector的方式，不过nio更适合大量连接的情况，对于移动平台有点杀鸡用牛刀的味道

Picasso、UIL都不支持inbitmap，项目中有用到Picasso的富图片应用需要注意这点

如果是标准的RESTful API,那么用Retrofit会非常爽！网络交互部分代码量可以减少90%。同时支持Gson,契合度很高。另外，Retrofit和OkHttp是亲兄弟，建议一起用，OkHttp是底层库，能够支持一些非标准的HTTP方法，比如PATCH方法。

选最适合项目的，选大多数人选择的，选简单易用的。关于如何选择开源library，可以参考。