您好,欢迎来到源码搜藏!分享精神,快乐你我!提示:担心找不到本站?在百度搜索“源码搜藏”,网址永远不丢失!
  • 首 页
  • 在线工具
  • jquery手册
  • 当前位置:首页 > 安卓源码 > 技术博客 >

    基于Retrofit、OkHttp、Gson封装通用网络框架

    时间:2017-09-06 22:06 来源:互联网 作者:源码搜藏 浏览:收藏 挑错 推荐 打印

    背景 android开发过程中网络请求作为最重要的组成部分之一,然而对于大部分android开发者在网络请求上有太多疑惑,不知道如何去选型?通过原生的HttpClient、HttpUrlConnection封装?还是通过第三方框架再封装?笔者以为采用广泛被使用的第三方网络框架再封装为上

    背景

    android开发过程中网络请求作为最重要的组成部分之一,然而对于大部分android开发者在网络请求上有太多疑惑,不知道如何去选型?通过原生的HttpClient、HttpUrlConnection封装?还是通过第三方框架再封装?笔者以为采用广泛被使用的第三方网络框架再封装为上策,因为这些网络框架如retrofit、okhttp、volley等是被全球android开发者维护着,无论在功能上、性能上、还是代码简洁性都相对于自己通过原生实现的给力.

    目的

    致力封装一个简洁、实用、易移植的网络框架模块.

    正题

    今天笔者就给大家基于retrofit + okhttp + gson 封装一个通用易懂的网络框架模块.
    首先我们需要在gradle文件中将第三方依赖引入项目,代码如下:

    dependencies {
        // retrofit + okhttp + gson
        compile 'com.squareup.retrofit2:retrofit:2.1.0'
        compile 'com.squareup.okhttp3:okhttp:3.4.1'
        compile 'com.google.code.gson:gson:2.7'
        compile 'com.squareup.retrofit2:converter-gson:2.1.0'
    }

    接着开始我们的封装之路......

    首先我们需要写一个参数常量类,用于定义一些常量,如请求Url地址、接口返回信息,代码如下:

    /**
     * @className: InterfaceParameters
     * @classDescription: 参数配置
     * @author: leibing
     * @createTime: 2016/8/30
     */
    
    public class InterfaceParameters {
        // 请求URL
        public final static String REQUEST_HTTP_URL = BuildConfig.API_URL;
        // 接口返回结果名称
        public final static String INFO = "info";
        // 接口返回错误码
        public final static String ERROR_CODE = "errorcode";
        // 接口返回错误信息
        public final static String ERROR_MSG = "errormsg";
    }

    然后写一个网络请求封装类JkApiRequest.class,采用单例的方式,配置网络请求参数以及返回网络请求api实例,代码如下:

    /**
     * @className:JkApiRequest
     * @classDescription:网络请求
     * @author: leibing
     * @createTime: 2016/8/30
     */
    public class JkApiRequest {
        // sington
        private static JkApiRequest instance;
        // Retrofit object
        private Retrofit retrofit;
    
        /**
         * Constructor
         * @author leibing
         * @createTime 2016/08/30
         * @lastModify 2016/08/30
         * @param
         * @return
         */
        private JkApiRequest(){
            OkHttpClient client = new OkHttpClient.Builder()
                    .addInterceptor(new OkHttpInterceptor())
                    .build();
            retrofit = new Retrofit.Builder()
                    .baseUrl(InterfaceParameters.REQUEST_HTTP_URL)
                    .addConverterFactory(JkApiConvertFactory.create())
                    .client(client)
                    .build();
        }
    
        /**
         * sington
         * @author leibing
         * @createTime 2016/08/30
         * @lastModify 2016/08/30
         * @param
         * @return
         */
        public static JkApiRequest getInstance(){
            if (instance == null){
                instance = new JkApiRequest();
            }
            return instance;
        }
    
        /**
         * create api instance
         * @author leibing
         * @createTime 2016/08/30
         * @lastModify 2016/08/30
         * @param service api class
         * @return
         */
        public <T> T create(Class<T> service) {
            return retrofit.create(service);
        }
    }

    上面代码有两个网络请求参数需要注意, OkHttpInterceptor 、JkApiConvertFactory.
    OkHttpInterceptor 作为网络请求拦截器,可以拦截请求的数据以及响应的数据,有助于我们排查问题,而JkApiConvertFactory 是作为Convert工厂,这里我所做的就是解析返回来的数据,将数据进行Gson处理就是在这里面.

    OkHttpInterceptor代码如下:

    /**
     * @className: OkHttpInterceptor
     * @classDescription: Http拦截器
     * @author: leibing
     * @createTime: 2016/08/30
     */
    public class OkHttpInterceptor implements Interceptor {
    
        private static final Charset UTF8 = Charset.forName("UTF-8");
    
        @Override
        public Response intercept(Chain chain) throws IOException {
    
            Request request = chain.request();
    
            // 获得Connection,内部有route、socket、handshake、protocol方法
            Connection connection = chain.connection();
            // 如果Connection为null,返回HTTP_1_1,否则返回connection.protocol()
            Protocol protocol = connection != null ? connection.protocol() : Protocol.HTTP_1_1;
            // 比如: --> POST http://121.40.227.8:8088/api http/1.1
            String requestStartMessage = "--> " + request.method() + ' ' + request.url() + ' ' + protocol;
    
            System.out.println("ddddddddddddddddddd requestStartMessage = " + requestStartMessage);
    
            // 打印 Response
            Response response;
            try {
                response = chain.proceed(request);
            } catch (Exception e) {
                throw e;
            }
            ResponseBody responseBody = response.body();
            long contentLength = responseBody.contentLength();
    
            if (bodyEncoded(response.headers())) {
    
            } else {
                BufferedSource source = responseBody.source();
                source.request(Long.MAX_VALUE); // Buffer the entire body.
                Buffer buffer = source.buffer();
                Charset charset = UTF8;
                if (contentLength != 0) {
                    // 获取Response的body的字符串 并打印
                    System.out.println("ddddddddddddddddddddddddd response = " + buffer.clone().readString(charset));
                }
            }
            return response;
        }
    
        private boolean bodyEncoded(Headers headers) {
            String contentEncoding = headers.get("Content-Encoding");
            return contentEncoding != null && !contentEncoding.equalsIgnoreCase("identity");
        }
    }

    JkApiConvertFactory代码如下:

    /**
     * @className: JkApiConvertFactory
     * @classDescription: this converter decode the response.
     * @author: leibing
     * @createTime: 2016/8/30
     */
    public class JkApiConvertFactory extends Converter.Factory{
    
        public static JkApiConvertFactory create() {
            return create(new Gson());
        }
    
        public static JkApiConvertFactory create(Gson gson) {
            return new JkApiConvertFactory(gson);
        }
    
        private JkApiConvertFactory(Gson gson) {
            if (gson == null) throw new NullPointerException("gson == null");
        }
    
        @Override
        public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
            return new GsonResponseBodyConverter<>(type);
        }
    
        final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
            private final Type type;
    
            GsonResponseBodyConverter(Type type) {
                this.type = type;
            }
    
            @Override public T convert(ResponseBody value) throws IOException {
                BaseResponse baseResponse;
                String reString;
                try {
                    reString = value.string();
                    // 解析Json数据返回TransData对象
                    TransData transData = TransUtil.getResponse(reString);
                    try {
                        if (transData.getErrorcode().equals("0") &&  !TextUtils.isEmpty(transData.getInfo())) {
                            baseResponse = new Gson().fromJson(transData.getInfo(), type);
                            baseResponse.setSuccess(transData.getErrorcode().equals("0"));
                            baseResponse.setInfo(transData.getInfo());
                            baseResponse.setInfo(transData.getInfo());
                        } else {
                            baseResponse = (BaseResponse) StringUtil.getObject(((Class) type).getName());
                            baseResponse.setSuccess(transData.getErrorcode().equals("0"));
                            baseResponse.setInfo(transData.getInfo());
                            baseResponse.setInfo(transData.getInfo());
                        }
                        return (T)baseResponse;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //从不返回一个空的Response.
                baseResponse = (BaseResponse) StringUtil.getObject(((Class) type).getName());
                try {
                    baseResponse.setSuccess(false);
                    //JkApiConvertFactory can not recognize the response!
                    baseResponse.setErrormsg("");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    return (T)baseResponse;
                }
            }
        }
    }

    接着我们写api接口,我这里是将对应的接口封装到对应的类中,这样当前api类中接口名称可以统一起来,请求api的方法也写入当前api类,这样做既能解耦又能减少在使用处的冗余代码,代码如下:

    /**
     * @className: ApiLogin
     * @classDescription: 登陆api
     * @author: leibing
     * @createTime: 2016/8/12
     */
    public class ApiLogin {
        // api
        private ApiStore mApiStore;
    
        /**
         * Constructor
         * @author leibing
         * @createTime 2016/08/30
         * @lastModify 2016/08/30
         * @param
         * @return
         */
        public ApiLogin() {
            // 初始化api
            mApiStore = JkApiRequest.getInstance().create(ApiStore.class);
        }
    
        /**
         * 登录
         * @author leibing
         * @createTime 2016/08/30
         * @lastModify 2016/08/30
         * @param username 用户名
         * @param password 密码
         * @param callback 回调
         * @return
         */
        public void Login(String username, String password, ApiCallback<LoginResponse> callback){
            Call<LoginResponse> mCall =  mApiStore.login(URLEncoder.encode(username), password);
            mCall.enqueue(new JkApiCallback<LoginResponse>(callback));
        }
    
        /**
         * @interfaceName: ApiStore
         * @interfaceDescription: 登录模块api接口
         * @author: leibing
         * @createTime: 2016/08/30
         */
        private interface ApiStore {
            @GET("app/User/Login")
            Call<LoginResponse> login(
                    @Query("username") String username,
                    @Query("userpass") String userpass);
        }
    }

    从上面代码我们看到ApiCallback和JkApiCallback两个回调接口,这两者区别在哪呢?观察仔细的童鞋会发现这个问题.ApiCallback接口是作为通用接口,而JkApiCallback是作为一个接口封装类,针对不同数据情景,做不同回调.

    ApiCallback代码如下:

    /**
     * @className: ApiCallback
     * @classDescription: Api回调
     * @author: leibing
     * @createTime: 2016/08/30
     */
    public interface ApiCallback<T> {
        // 请求数据成功
        void onSuccess(T response);
        // 请求数据错误
        void onError(String err_msg);
        // 网络请求失败
        void onFailure();
    }

    JkApiCallback代码如下:

    public class JkApiCallback<T> implements Callback <T>{
        // 回调
        private ApiCallback<T> mCallback;
    
        /**
         * Constructor
         * @author leibing
         * @createTime 2016/08/30
         * @lastModify 2016/08/30
         * @param mCallback 回调
         * @return
         */
        public JkApiCallback(ApiCallback<T> mCallback){
            this.mCallback = mCallback;
        }
    
        @Override
        public void onResponse(Call<T> call, Response<T> response) {
            if (mCallback == null){
                throw new NullPointerException("mCallback == null");
            }
            if (response != null && response.body() != null){
                if (((BaseResponse)response.body()).isSuccess()){
                    mCallback.onSuccess((T)response.body());
                }else {
                    mCallback.onError(((BaseResponse) response.body()).getErrormsg());
                }
            }else {
                mCallback.onFailure();
            }
        }
    
        @Override
        public void onFailure(Call<T> call, Throwable t) {
            if (mCallback == null){
                throw new NullPointerException("mCallback == null");
            }
            mCallback.onFailure();
        }
    }

    接下来我们写Response类,用于接收Gson解析回来的数据,这个只需写json数据信息里面的字段.代码如下:

    /**
     * @className: LoginResponse
     * @classDescription: 获取登录返回的信息
     * @author: leibing
     * @createTime: 2016/08/30
     */
    public class LoginResponse extends BaseResponse implements Serializable{
        // 序列化UID 用于反序列化
        private static final long serialVersionUID = 4863726647304575308L;
        // token
        public String accesstoken;
    }

    阅读仔细的童鞋会发现,在Convert工厂中Gson解析时,用到了一个BaseResponse,这个响应类是作为基类,就是服务端返回的固定json数据格式,因为每个项目返回的固定格式可能不一样,所以只需改这里,就能定制对应项目的网络框架.
    BaseResponse代码如下:

    /**
     * @className: BaseResponse
     * @classDescription: 网络请求返回对象公共抽象类
     * @author: leibing
     * @createTime: 2016/08/30
     */
    public class BaseResponse implements Serializable {
        // 序列化UID 用于反序列化
        private static final long serialVersionUID = 234513596098152098L;
        // 是否成功
        private boolean isSuccess;
        // 数据
        public String info;
        // 错误消息
        public String errormsg;
    
        public boolean isSuccess() {
            return isSuccess;
        }
    
        public void setSuccess(boolean success) {
            isSuccess = success;
        }
    
        public String getInfo() {
            return info;
        }
    
        public void setInfo(String info) {
            this.info = info;
        }
    
        public String getErrormsg() {
            return errormsg;
        }
    
        public void setErrormsg(String errormsg) {
            this.errormsg = errormsg;
        }
    }

    一个简洁、实用、易移植的网络框架模块封装完毕

    基于Retrofit、OkHttp、Gson封装通用网络框架转载http://www.codesocang.com/appboke/36567.html
    标签:网站源码