Android开发中常用网络框架例举综合

Android开发中常用网络框架例举综合

本篇简单总结各个框架的使用，以Get请求、JSON解析、图片加载为例。

分别使用6个框架HttpURLConnection、HttpClient、AndroidAsyncHttp、Volley、OkHttp、Retrofit2(排序根据提出的时间和学习的顺序)

1.HttpURLConnection

---

HttpURLConnection是较为基础的网络框架，是Android6.0以后版本默认的底层网络。
（同步的，需要自己封装线程）

    static String host_address = "http://10.0.2.2:8080/listdata/";

    /**
    *   根据指定的Url来获取byte数据
    */
    public static byte[] getData(String path) {
        path = host_address + path;
        byte[] data = null;
        URL url = null;
        try {
            // 1.创建url对象
            url = new URL(path);
            // 2.开启链接引用
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
            // 3.设置链接事件
            urlConnection.setReadTimeout(5000);
            urlConnection.setConnectTimeout(5000);
            urlConnection.setRequestMethod("GET");
            // 4.连接成功获取数据
            if (urlConnection.getResponseCode() == 200) {
                InputStream is = urlConnection.getInputStream();
                data = BytesUtil.getBytes(is);
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return data;
    }

    /**
     * 获取字符串
     */
    public static String getString(String path) {
        byte[] data = getData(path);
        try {
            return new String(data, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 获取bitmap
     */
    public static Bitmap getBitmap(String path) {
        byte[] data = getData(path);
        Bitmap sBitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
        return sBitmap;
    }


    /**
     * 设置对应imageview的bitmap，注意listview的复用问题
     */
    public static void setViewImage(final ImageView view, final String path) {
        // 打上标记防止复用view时造成图片加载混乱
        view.setTag(path);
        new Thread() {
            public void run() {
                final Bitmap bitmap = getBitmap(path);
                view.post(new Runnable() {
                    public void run() {
                        //核对标记的一致
                        if (view.getTag().equals(path))
                            view.setImageBitmap(bitmap);
                    }
                });
            }
        }.start();
    }

2.HttpClient

---

HttpClient是Apache提供的已经高度封装的网络请求端，在使用中他可以看作是一个网络客户端。
（同步的，需要自己封装线程，支持回调处理）

添加jar包：

在sdk路径中 ~\platforms\android-23\optional\org.apache.http.legacy.jar

    static String host_address = "http://10.0.2.2:8080/listdata/";

    /**
     * 请求网络获取数据
     */
    public static byte[] getData(String path) {
        byte[] execute = null;
        // 1.一个默认的httpclient
        DefaultHttpClient client = new DefaultHttpClient();
        // 2.创建一个get请求httpGet
        HttpGet httpGet = new HttpGet(host_address + path);
        try {
            // 3.httpclient执行这个请求
            HttpResponse response = client.execute(httpGet);
            // 4.判断响应状态
            int responseCode = response.getStatusLine().getStatusCode();
            if (responseCode == HttpStatus.SC_OK) {
                // 5.HttpEntity响应内容
                HttpEntity entity = response.getEntity();
                // 6.响应体中获取流对象
                execute = BytesUtil.getBytes(entity.getContent());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return execute;
    }

    //String解析，图片解析，方式与HttpUrlConnection相同 

其在使用时的流程为下：

3.Android-Async-Http

---

AsyncHttp是一个支持异步的框架，其内部进行的封装使得用起来非常简单，但让代码结构看起来很差，会让网络设计的代码与UI部分混在一起。注意Asnyc-Http与AsyncTask<Params, Progress, Result>并非同一个事物，初学者在这里会混淆。

添加Module：

compile ‘com.loopj.android:android-async-http:1.4.9’

    // 在应用中应全局使用一个Client避免不必要的重复
    AsyncHttpClient sClient = new AsyncHttpClient();
    // 使用非常简单，仅仅调取sClient的get方法即可实现一个网络请求
    // 通过添加处理回调的方式实现异步
    sClient.get(host_address + url,new AsyncHttpResponseHandler() {
        // 连接成功时的回调，responseBody即为响应流中的数据
        public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
            mListData.addAll(JsonUtil.parse(ListData.class, new String(responseBody)).list);
            mInnerAdapter.notifyDataSetChanged();
        }

        // 连接失败的回调
        public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
            error.printStackTrace();
        }

    });

AsyncHttp已经提供了很多Hanlder供开发者使用，默认的有：

4.Volley

---

Volley是官方提供的网络解析框架，其底层使用了HttpURLConnection。其具备AsyncHttp和ImageLoader的特点，支持异步加载并采用回调，支持网络缓存，并提供支持缓存管理的ImageLoader，但是缓存需要我们自己完成，下面有使用样例。

添加Module:

compile ‘eu.the4thfloor.volley:com.android.volley:2015.05.28’

在使用前需要初始化一个Volley的处理队列

    //他必须在Application中声明
    public class MyApplication extends Application {

    private static RequestQueue mRequestQueue;

    @Override
    public void onCreate() {
        super.onCreate();
        // 为volley声明一个队列
        mRequestQueue = Volley.newRequestQueue(this);
    }

    public static RequestQueue getRequestQueue() {
        return mRequestQueue;
    }
}

1.像AsyncHttp那样拿到数据再解析再处理，Volley中请求需要被封装为一个Request对象，并在其中实现对Response的处理封装。

    static String host_address = "http://10.0.2.2:8080/listdata/";

    /**
     * 使用自定义request的方式去获取json数据,不会有乱码
     */
    public static void getData(String url, final List<ListData.Data> dataList, final BaseActivity.InnerAdapter adapter) {

        // 1.使用自定义实现Request，参数中null为ErrorListener可以不处理
        Request<String> request = new Request<String>(Request.Method.GET, host_address + url, null) {

            // 2.网络数据解析过程，通过Response的Api可以获取一个默认的封装
            protected Response<String> parseNetworkResponse(NetworkResponse response) {
                byte[] data = response.data;

                // 3.Entry是指定缓存类型中的条目,注意这里如果不想缓存可取消缓存
                return Response.success(new String(data), HttpHeaderParser.parseCacheHeaders(response));
            }

            // 3.解析结果的处理
            protected void deliverResponse(String response) {
                ListData parse = JsonUtil.parse(ListData.class, response);
                dataList.addAll(parse.list);
                adapter.notifyDataSetChanged();
            }
        };
        // 取消缓存
        // request.setShouldCache(false);
        sRequestQueue.add(request);
    }

2.使用默认的StringRequest处理json数据

    public static void getString(String url, final List<ListData.Data> dataList, final BaseActivity.InnerAdapter innerAdapter) {

        // 使用默认的StringRequest需要添加响应成功的监听和失败的监听
        sRequestQueue.add(
            new StringRequest(Request.Method.GET, host_address + url, new Response.Listener<String>() {
            // 重写该方法，实现对String结果的处理
            public void onResponse(String response) {
                ListData parse = JsonUtil.parse(ListData.class, response);
                dataList.addAll(parse.list);
                innerAdapter.notifyDataSetChanged();
            }
        }, new Response.ErrorListener() {
            // 重写该方法实现对异常情况的处理
            public void onErrorResponse(VolleyError error) {
                error.printStackTrace();
                Log.e("tag", "error");
            }
        }) {
            //重写StringRequst中文字解析的过程，修复文字乱码的问题
            protected Response<String> parseNetworkResponse(NetworkResponse response) {
                String parsed;
                try {
                    // 源码中的文字编码是获取自网络响应头中的，与U8不同时会造成乱码
                    // parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
                    parsed = new String(response.data, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    parsed = new String(response.data);
                }
                return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
            }
        });
    }

3.使用默认的ImageRequest加载图片

    /**
     * 使用与StringRequest相同，但低效率，很慢，画质差
     */
    public static void getViewImage_request(final ImageView imageView, final String url) {
        // 设置标记进行校验，防止listview复用造成图片错位
        imageView.setTag(url);
        sRequestQueue.add(new ImageRequest(host_address + url, new Response.Listener<Bitmap>() {
            @Override
            public void onResponse(Bitmap response) {
                // 校验标记
                if (imageView.getTag().equals(url))
                    imageView.setImageBitmap(response);
            }
        }, 0, 0, Bitmap.Config.ARGB_8888, new Response.ErrorListener() {
            public void onErrorResponse(VolleyError error) {
                // empty
            }
        }));
    }

4.采用ImageLoader的方式来管理图片加载

ImageLoader(RequestQueue queue, ImageCache imageCache) // ImageLoader的构造方法

ImageLoader需要提供一个imagecache作为缓存处理的方式，但imagecache中是如何处理缓存的由我们来实现，这里采用lrucache集合的形式在内存中缓存，当然也可以使用其他想要的缓存方式。

    private static ImageLoader.ImageCache sImageCache;
    private static LruCache<String, Bitmap> sLruCache;
    private static ImageLoader sImageLoader;

    public static void getViewImage_loader(String url, ImageView imageView) {
        // volley没有实现默认的缓存，需要我们自己实现

        // 1.初始化一个默认大小的内存缓存
        if (sLruCache == null) {
            sLruCache = getLruCache();
        }

        // 2.将对应的bitmap缓存存取方式进行封装
        if (sImageCache == null)
            sImageCache = new ImageLoader.ImageCache() {
                @Override
                public Bitmap getBitmap(String url) {
                    return sLruCache.get(url);
                }

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

        // 3.根据已经创建好的imageCache和requestQueue来初始化一个新的imageLoader
        if (sImageLoader == null)
            sImageLoader = new ImageLoader(MyApplication.getRequestQueue(), sImageCache);

        // 4.为对应的imageView生成一个默认的imageListener，设置初始图片和失败图片
        ImageLoader.ImageListener listener = ImageLoader.getImageListener(imageView, R.mipmap.ic_launcher, R.mipmap.ic_launcher);

        // 5.使用ImageLoader的get请求这个加载，内部仍然是ImageRequest
        sImageLoader.get(host_address + url, listener);
    }

    /**
     * 获取一个LruCache，最近最少使用算法也是较为容易理解的一种算法
     */
    private static LruCache getLruCache() {
        long maxMemory = Runtime.getRuntime().maxMemory();
        long cacheSize = maxMemory / 8;
        sLruCache = new LruCache<String, Bitmap>((int) (cacheSize / 1024)) {

            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
        return sLruCache;
    }

5.OkHttp

---

OkHttp是现在较为流行的网络框架之一，他与HttpClient的相似之处在于都可将网络看作一个Client，并通过Client执行一个封装的request再从执行的结果Response中获取数据。

但不同的是，OkHttp中Client并非直接execute而是newCall返回一个Call对象，在Call对象中我们可以使用同步的方式处理或者异步的方式处理，并且可以控制这条请求的开关call.cancel()。

添加Module：

compile ‘com.squareup.okhttp:okhttp:2.0.0’

    static String host_address = "http://10.0.2.2:8080/listdata/";

    public static OkHttpClient mClient = new OkHttpClient();

    /**
     * OKHttp用法与HttpClient类似
     */
    public static byte[] getData(String url) throws IOException {
        // 1.通过Builder建造 Request
        Request.Builder builder = new Request.Builder();
        // 2.链式编程设置url和请求方式
        builder.url(host_address + url).
                get();
        // 3.建造出指定的request
        Request request = builder.build();
        // 4.获取request已经实现了CallFactory工厂，使用其进行生产
        Call call = mClient.newCall(request);
        // 5.执行对应的call获取响应对象（同步）
        Response response = call.execute();
        // 6.判断响应状态
        if (response.code() == 200) {
            // 7.获取响应体
            ResponseBody body = response.body();
            // 8.直接获取相应体中数据，也可以获取流对象，只有输入流
            return body.bytes();
        }
        return null;
    }

    //String解析，图片解析，方式与HttpUrlConnection相同 

异步方式，通过给call添加回调来处理结果

    call.enqueue(new Callback() {
        public void onFailure(Request request, IOException e) {
            // empty
        }
        public void onResponse(Response response) throws IOException {
            // TODO
        }
    });

OkHttp的执行流程：

6.Retrofit2

---

Retrofit经常与OkHttp搭配使用，其采用注解的方式简化网络请求代码的书写(此处有坑)，并支持常规的callback方式，也支持observer的RxJava模式。(反正就是很牛，因为是初学所以本篇只是简单使用了一下，体现出怎么解析json数据、图片加载，并与前面几种方式形成对比)。

添加Module：

compile 'com.squareup.retrofit2:retrofit:2.1.0'//Retrofit2所需要的包
compile 'com.squareup.retrofit2:converter-gson:2.1.0'//ConverterFactory的Gson依赖包
compile 'com.squareup.retrofit2:converter-scalars:2.1.0'//ConverterFactory的String依赖包
compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0' //RxJavaCallAdapter依赖包
compile 'io.reactivex:rxandroid:1.2.1' // RxAndroid依赖包

1.配置一个全局的Retrofit，这一点与前面几个方法很相似

    private static Retrofit sRetrofit;

    private static Retrofit getRetrofit() {
        // 1.初始化一个建造者
        Retrofit.Builder builder = new Retrofit.Builder();

        // 2.添加主机地址
        builder.baseUrl(HttpUrl.parse("http://10.0.2.2:8080"))
                // .client(mOkHttpClient)可以使用指定的OkHttpClient
                // 3.添加数据转换工厂
                .addConverterFactory(ScalarsConverterFactory.create())// 处理基本数据类型
                .addConverterFactory(GsonConverterFactory.create())// 处理gson数据类型
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())// 添加回调的适配器，RxJava的回调形式（即非callback的形式）;

        // 4.生成配置好的retrofit
        return builder.build();
    }

2.将对应的服务器api接口封装为本地接口，这里方法返回Call对象方便使用和理解，Observable对象是RxJava中使用到的，但也可以使用Call的形式进行处理

    public interface ListDataService {
        @GET("/listdata/{datapath}")
        Call<ListData> getListData(@Path("datapath") String path);

        // （坑！）BUG:这里采用了切割，因为Retrofit将链接中的"/"转义为"%2F"造成请求失败 错误码400
        @GET("/listdata/app/{package}/{icon}")
        Observable<ResponseBody> getBitmap(@Path("package") String packageName, @Path("icon") String icon);

    }

3.将本地接口生成对应的实例

    private static ListDataService sService;
    /**
     * 根据已经构造的服务，获取api的接口服务实例
     */
    public static ListDataService getService() {
        // 1.获取retrofit
        if (sRetrofit == null)
            sRetrofit = getRetrofit();
        // 2.使用retrofit创建对应api的接口
        if(sService == null)
            sService = sRetrofit.create(ListDataService.class);
        return sService;
    }

4.使用接口中的方法

使用返回的Call对象，采用异步的方式执行，当然也可以使用同步的方式（与OkHttp中的execute）。

Call对象的用法OkHttp中的Call对象相同。

解析Json数据

    public static void getListData(String path, Callback<ListData> callback) {
        // 1.检查是否有sService
        if (sService == null)
            sService = getService();
        // 2.调用接口方法，获取Call
        Call<ListData> listdata = sService.getListData(path);
        // 3.执行Call并为其添加回调
        listdata.enqueue(callback);
        // 同步
        // listdata.execute().body();
    }

解析图片数据，这里使用了RxJava的回调形式

    public static void setViewImage(String path, final ImageView view) {
        // 1.检查是否有sService
        if (sService == null)
            sService = getService();
        // 切割字符串避免"/"被转义
        String[] split = path.split("/");
        String packageName = split[1];
        String icon = split[2];

        // 2.实现retrofit的图片加载
        Observable<ResponseBody> bitmap = sService.getBitmap(packageName, icon);
        bitmap.subscribeOn(Schedulers.io()) // 设置注册观察者的线程
                .observeOn(AndroidSchedulers.mainThread())// 设置观察者响应的线程，要添加RxAndroid
                .subscribe(new Observer<ResponseBody>() { // 注册观察者
                    @Override
                    public void onCompleted() {
                        // 在所有的next事件都被执行了之后
                        Log.i("RxJava","onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        e.printStackTrace();
                    }

                    @Override
                    public void onNext(ResponseBody responseBody) {
                        view.setImageBitmap(BitmapFactory.decodeStream(responseBody.byteStream()));
                    }
                });
    }

更多Retrofit详情：
Retrofit 2.0 自定义Converter、
Retrofit用法详解

更多RxJava详情：
给 Android 开发者的 RxJava 详解、
深入浅出RxJava（一：基础篇）

演示

---

样例：