架构师之路-网络框架的搭建（高逼格）

一，了解常见的框架

1,你已经工作量3年不等或也许是菜鸟，只要接触Android开发那么在项目中必不可少的就是一些第三方框架：常见的网络请求框架，图片加载框架等…

我们具体了解下常见的网络框架：
网络框架：okhttp,Volley,Xutils,Retrofit....
图片框架：picasso，xutils,imageLoader,glide,fresco,Fac...

他们的优点：兼容性好，代码很少，逼格够高，封装….这么多的优点，也许刚接触开发的很多小伙子们直接拿来就在项目中使用。哪里需要网络请求哪里直接上代码也不是很费劲！如果你是这样做的你这时候应该看完我这篇博客啦！

二，不同级别人使用框架的方式
（1）:第一种初级程序员：
1,初级程序员做法：拿来就用
2,优点：简单粗暴
3,做法如下：

 x.http().get(new RequestParams(url), new 
        Callback.CommonCallback<String>() {   

         @Override
         public void onSuccess(String result) {

         }

        @Override
        public void onError(Throwable ex, boolean isOnCallback) {

            }

            @Override
            public void onCancelled(CancelledException cex) {

            }

            @Override
            public void onFinished() {

            }
        });

4,缺点： 耦合度太高：因为一个大型项目中用到的网络框架部分有可能成千上万，如果你是程序员，你所使用的网络请求框架不满足产品的需求时候，你是要一个一个来修改么？这么多交互代码是不是很难，很耗费时间。效率极低。
（2）:第二种中级程序员：
1,中级程序员做法：为了降低耦合度进行了一次封装：
2,有点：耦合度低，小小装逼，代码少了，逻辑清晰，使用方便。
3,做法如下：当然了我这里分装时候进行了一些简单的操作，单例模式，泛型。相信都可以看懂。将网络框架分装到类里面不在跟View交互

 package com.example.ls.mynetframe.volleyutils;

import android.content.Context;

import com.android.volley.AuthFailureError;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by 路很长~ on 2017/7/14.
 */

public class VolleyUtils<T> {
    public static VolleyUtils _instance;
    private RequestQueue requestQueue;

    //定义一个接口实现回掉
    public interface CallBack<T> {
        void onSuccess(T obj);
        void onFails(String onfail);
    }

    private VolleyUtils(Context context) {
        requestQueue = Volley.newRequestQueue(context);
    }

    //通过单利模式来保证只创建一个实例并且初始化Volley框架
    public static VolleyUtils getInstance(Context context) {
        if (_instance == null) {
            synchronized (VolleyUtils.class) {
                //初始化volley框架
                _instance = new VolleyUtils(context);
            }
        }
        return _instance;
    }

    //这里来宣布这个方法类型为<T>,这个编辑表示参数里面有泛型
    public <T> void getReques(String url, HashMap<String, Object> paramers, final CallBack<T> callBack) {
        final StringRequest request = new StringRequest(Request.Method.GET, HttpUtilss.appendParamers(url, paramers), new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                //  Gson gsonVolley=new Gson();
                T obj = (T) response;
                callBack.onSuccess(obj);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                callBack.onFails(error.toString());
            }
        });
        requestQueue.add(request);
    }

    public <T> void postRequest(String url, final Map<String, String> hashMap, final CallBack<T> callBack) {
        StringRequest request = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                T obj = (T) response;
                callBack.onSuccess(obj);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                callBack.onFails(error.toString());
            }
        }) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                if (hashMap != null) {
                    return hashMap;
                }
                return super.getParams();
            }
        };

    }

    public static class HttpUtilss {
        static String appendParamers(String url, HashMap<String, Object> paramers) {
            StringBuffer stringBuffer = new StringBuffer();
            for (HashMap.Entry<String, Object> enty : paramers.entrySet()) {
                String strin = "&" + enty.getKey() + "=" + enty.getValue();
                stringBuffer.append(strin);
            }
            return url + stringBuffer.toString();
        }
    }
}

4,缺点：但是这种简单的封装如果项目中需要维护替换网络框架，需要修改View里面的交互代码，也有大量的代码需要在View层修改。我们如何以一个架构师的角度考虑问题，在View层我们不需要修改代码。只需要修改我们的网络层框架封装类实现网络层代码的接口。

（3）:高级架构师
1,考虑的东西：
维护，复用，可拓展，简单实用，实用场景，开闭原则，逼格高，替换库简单。
2,分析图如下：我门首先分析需求：

我们在替换框架时候需求不要动View层交互代码，二，只需很少的代码实现替换框架，我们将所有的网络请求框架代码放在Volley，OkHttp封装类里面，实现网络层封装的接口，交互层我们也将其封装为一个类，且实现网络层封装的接口。替换库时候只替换最下面的Okhttp和Volley等封装类，只需要实现网络层里面的接口就行。其他不用动。我们可以看到交互层和View层是没有动的。

3,撸代码过程首先我们新建一个项目MyNetFrame：
第一部分：写网络层代码并将其封装在接口中：
(1.)
新建一个包okhttpframe，当然这个你们随便自己喜好来
我们从底部网上来实现：
首先定义一个强调内容接口DataICallBack网络请求结果无非两种成功失败：

public interface DataICallBack {
    //成功时候回调
    void onSuccess(String result);
    //失败时候回调
    void onFailure(String result);
}

(2.)
新建一个类来实现DataICallBack用来解析返回的json字符串为对象，我们这个类为抽象类符合开闭原则代码如下：
1，在里面使用了反射技术通过反向T，获取需要解析的实体类类型。getType(Object obj)方法。（不知道的回顾下java基础，这些代码写多了记住最好）
2，里面定义2个抽象方法来返回给调用层结果。

public abstract class FrameHttpCallback<T> implements DataICallBack {

    @Override
    public void onSuccess(String result) {
        Gson gson = new Gson();
        Type type = getType(this);
        T obj = gson.fromJson(result, type);
        onSuccess(obj);
    }

    public abstract String onSuccess(T t);
    public abstract String onFail(String s);

    @Override
    public void onFailure(String result) {
        onFail(result);
    }

    private static Type getType(Object obj) {
        Type types = obj.getClass().getGenericSuperclass();
        Type[] type_arr = ((ParameterizedType) types).getActualTypeArguments();
        return type_arr[0];
    }
}

(3.)将其网络层代码封装起来：
便于交互层和网络请求封装类的实现

public interface FrameHttpProcessor {
    //成功:
    void OnSuccess(String url, Map<String, Object> parames, FrameHttpCallback callback);

    //失败:
    void OnFails(String url, Map<String, Object> parames, FrameHttpCallback callback);
}

第二部分：为了解决网络交互层和View层不会见面，我们来个代理且实现网络层接口：
(1.) 我们定义一个代理类实现网络层接口代码如下

public class FrameHttpHelper implements FrameHttpProcessor {
    //这儿低耦合
    private static FrameHttpProcessor mFrameHttpProcessor;
    private static FrameHttpHelper _instance;

    public FrameHttpHelper() {
    }

    public void init(FrameHttpProcessor processor) {
        mFrameHttpProcessor = processor;
    }

    public static FrameHttpHelper getInstance() {
        synchronized (FrameHttpHelper.class) {
            if (_instance == null) {
                _instance = new FrameHttpHelper();
            }
            return _instance;
        }
    }

    @Override
    public void get(String url, Map<String, Object> parames, FrameHttpCallback callback) {
        //这里我们进行字符串的拼接
        String url_result = appendParamers(url, parames);
        mFrameHttpProcessor.get(url_result, parames, callback);
    }

    static String appendParamers(String url, Map<String, Object> paramers) {
        //1.获取最终URL方法一
        /* String url_result;
        url_result = url;
        Set<String> keyset = paramers.keySet();
        Object[] keyArray = keyset.toArray();
        for (int i = 0; i < keyArray.length; i++) {
            url_result += "&" + keyArray[i].toString() + "=" + paramers.get(keyArray[i].toString());
        }
        return url_result;*/
        /**
         * 2:方法二：
         StringBuffer stringBuffer = new StringBuffer();
         for (HashMap.Entry<String, Object> enty : paramers.entrySet()) {
         String strin = "&" + enty.getKey() + "=" + enty.getValue();
         stringBuffer.append(strin);
         }
         return url + stringBuffer.toString();**/

        if (paramers == null && paramers.isEmpty()) {
            return url;
        }
        StringBuilder urlBuider = new StringBuilder(url);

        if (urlBuider.indexOf("?") <= 0) {
            urlBuider.append("?");
        } else {
            if (!urlBuider.toString().endsWith("?")) {
                urlBuider.append("&");
            }
        }
        for (Map.Entry<String, Object> entry : paramers.entrySet()) {
            urlBuider.append(entry.getKey()).append("=").append(entry.getValue().toString());
        }
        return urlBuider.toString();
    }

    @Override
    public void post(String url, Map<String, Object> parames, FrameHttpCallback callback) {
        //这里我们进行字符串的拼接
        String url_result = appendParamers(url, parames);
        mFrameHttpProcessor.get(url_result, parames, callback);
    }
}

第三部分：我们正式的写我们的Volley封装框架类：
(1.) 我们定义一个VolleyFrameProcessor类实现FrameHttpProcessor在这个类里面真正写网络请求代码，达到隔绝View层：

public class VolleyFrameProcessor implements FrameHttpProcessor {
    RequestQueue mRequstQue;

    public VolleyFrameProcessor(Context context) {
        mRequstQue = Volley.newRequestQueue(context);
    }

    @Override
    public void get(String url, Map<String, Object> parames, final FrameHttpCallback callback) {
        StringRequest request = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                callback.onSuccess(response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                callback.onFailure(error.toString());
            }
        });
        mRequstQue.add(request);
    }

    @Override
    public void post(String url, Map<String, Object> parames, final FrameHttpCallback callback) {
        StringRequest request = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                callback.onSuccess(response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                callback.onFailure(error.toString());
            }
        });
    }
}

第四部分：我们就可以拿来用了：
首先在MyApplication里面进行注册：

FrameHttpHelper.init(new VolleyFrameProcessor(this));

在MainActivity里面调用代码：

 HashMap<String, Object> paramss = new HashMap<>();
        paramss.put("mode", "bottom_hot_boards");

        paramss.put("platform", "Android");


        FrameHttpHelper.getInstance().get(Config.PATH_URL,paramss,new 
        FrameHttpCallback<BeanJson>(){

            @Override
            public void onSuccess(BeanJson beanJson) {
                mTv_hollo.setText(beanJson.getMsg().toString());

            }

            @Override
            public void onFail(String s) {
              Toast.makeText(MainActivity.this, "", Toast.LENGTH_LONG).show();

            }
        });

对了我网络接口里面的json数据是如下

{msg='参数错误', result=-9109, success=false}
我调取的msg所以显示“参数错误”，并不是我的参数错了哦！你们自己找接口试试。我这个接口就这么点东西，我懒的找了！

三，当需求来了我们需要替换框架时候：
要求把Volley框架替换为Okhttp:
具体做法如下：
1，定一个类实现FrameHttpProcessor接口：

public class OkhttpFrameProcessor implements IHttpProcessor {//实现这个接口
    private OkHttpClient mOkhttClient;
    private Handler mHandler;

    public OkhttpFrameProcessor() {
        mOkhttClient = new OkHttpClient();
        mHandler = new Handler();
    }

    private RequestBody appendBody(Map<String, Object> paramers) {
        FormBody.Builder body = new FormBody.Builder();
        if (paramers == null || paramers.isEmpty()) {
            return body.build();
        }
        for (Map.Entry<String, Object> entry : paramers.entrySet()) {
            body.add(entry.getKey(), entry.getValue().toString());
        }
        return body.build();
    }

    @Override
    public void get(String url, Map<String, Object> parames, final ICallback callback) {
        final Request request = new Request.Builder()
                .get()
                .url(url)
                .build();

        mOkhttClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, final IOException e) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onFailure(e.toString());
                    }
                });
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    final String result = response.body().string();
                    Log.e("resutlxx", result.toString());
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            callback.onSuccess(result);
                        }
                    });
                } else {
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            callback.onFailure("访问失败！");
                        }
                    });
                }
            }
        });


    }

    @Override
    public void post(String url, Map<String, Object> parames, final ICallback callback) {
        RequestBody requestBody = appendBody(parames);
        final Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .header("User-Agent", "a")
                .build();
        mOkhttClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, final IOException e) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onFailure(e.toString());
                    }
                });
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {
                if (response.isSuccessful()) {
                    final String result = response.body().string();
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            callback.onSuccess(result);
                        }
                    });
                } else {

                }

            }
        });
    }
}

2,在MyApplication里面替换为：

FrameHttpHelper.init(new OkhttpFrameProcessor());

就完事了，我们可以看到我们在View层什么事都没干，只需要自己封装框架类，实现网络层封装接口。在MyApplication初始化就可以。

最后：高逼格架构师网络基本框架就完了，告诉你们这个框架是“三星”这样的大佬公司使用的网络框架哦，都8点了，我要吃饭去了，下一章开始封装图片框架哦，希望交流讨论！一起进步！