一骑绝尘Louisk

Android OkHttp框架解析

Okhttp是由Sqare公司开发的开源网络访问库，是目前比较火的网络框架，它处理了很多网络疑难杂症：会从很多常用的连接问题中自动恢复。如果你的服务器配置了多个IP地址，当第一个IP连接失败的时候，OkHttp会自动尝试下一个IP，此外OkHttp还处理了代理服务器问题和SSL握手失败问题。
首先介绍下OkHttp的简单使用，主要包含：

同步/异步get请求
同步/异步post请求
基于Http的文件上传
文件下载
加载图片
支持请求回调，直接返回对象、对象集合
支持session的保持

使用前准备

Eclipse的用户，下载最新的okhttp jar包，导入工程。同时okhttp内部依赖okio，所以别忘了同时导入okio jar包。
okhttp 3.4.1.jar和okio-1.10.0.jar下载地址

Studio用户，直接添加依赖包：

compile 'com.squareup.okhttp3:okhttp:3.4.1'

然后添加网络访问权限：

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

OkHttp3用法

1. okHttp网络请求之Get/Post请求

1.异步GET请求
最简单的GET请求

private void getAsynHttp() {
        OkHttpClient mOkHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url("http://www.baidu.com")
                .build();
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                showlog(e.getMessage());
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                final String str = response.body().string();
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(getApplication(), str, Toast.LENGTH_SHORT).show();
                    }
                });
            }
        });
    }

基本的步骤很简单，就是创建OkHttpClient、Request和Call，最后调用Call的enqueue()方法。但是每次这么写肯定是很麻烦，肯定是要进行封装的。需要注意的是onResponse回调并不是在UI线程。
注：onResponse回调的参数是response，一般情况下，比如我们希望获得返回的字符串，可以通过response.body().string()获取；如果希望获得返回的二进制字节数组，则调用response.body().bytes()；如果你想拿到返回的inputStream，则调用response.body().byteStream()。

2.同步GET请求
同步Get请求和异步调用区别就是调用了call的execute()方法。

 private String getSyncHttp() throws IOException{
        OkHttpClient mOkHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url("http://www.baidu.com")
                .build();
        Call call = mOkHttpClient.newCall(request);
        Response mResponse=call.execute();
        if (mResponse.isSuccessful()) {
            return mResponse.body().string();
        } else {
            throw new IOException("Unexpected code " + mResponse);
        }
   }

注意同步GET请求的调用必须放在子线程中执行，不然会报NetworkOnMainThreadException。

3.异步POST请求
post与get不同的就是要创建RequestBody并传进Request中，同样onResponse回调不是在UI线程。

private void postAsynHttp() {
        OkHttpClient mOkHttpClient = new OkHttpClient();
        RequestBody formBody = new FormBody.Builder()
                .add("topicId", "1002")
                .add("maxReply", "-1")
                .add("reqApp", "1")
                .build();

        Request request = new Request.Builder()
                .url("http://61.129.89.191/SoarAPI/api/SoarTopic")
                .post(formBody)
                .build();
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                showlog(e.getMessage());
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                final String str = response.body().string();
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(getApplicationContext(), str, Toast.LENGTH_SHORT).show();
                    }
                });
            }
        });
    }

2. okHttp网络请求之文件上传下载

1.异步上传文件
上传文件本身也是一个POST请求，首先定义上传文件类型：

public final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("text/x-markdown; charset=utf-8");

将sdcard根目录的demo.txt文件上传到服务器上：

   private void postAsynFile() {
       OkHttpClient mOkHttpClient=new OkHttpClient();
       File file = new File("/sdcard/demo.txt");
       Request request = new Request.Builder()
               .url("https://api.github.com/markdown/raw")
               .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))
               .build();

       mOkHttpClient.newCall(request).enqueue(new Callback() {
               @Override
               public void onFailure(Call call, IOException e) {
                   showlog(e.getMessage());
               }

               @Override
               public void onResponse(Call call, Response response) throws IOException {
                   showlog(response.body().string());
               }
           });
       }

当然如果想要改为同步的上传文件只要调用 mOkHttpClient.newCall(request).execute()就可以了。
在demo.txt文件中有一行字“测试OkHttp异步上传”我们运行程序点击发送文件按钮，最终请求网络返回的结果就是我们txt文件中的内容：

当然不要忘了添加如下权限：

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

2.异步下载图片
下载图片本身也是一个GET请求

private void getAsynFile() {
       OkHttpClient mOkHttpClient = new OkHttpClient();
       Request request = new Request.Builder()
               .url("https://img-my.csdn.net/uploads/201309/01/1378037128_5291.jpg")
               .build();
       Call call = mOkHttpClient.newCall(request);
       call.enqueue(new Callback() {
           @Override
           public void onFailure(Call call, IOException e) {
            showlog(e.getMessage());
           }

           @Override
           public void onResponse(Call call, Response response) throws IOException {
               final byte[] data = response.body().bytes();
               runOnUiThread(new Runnable() {
                   @Override
                   public void run() {
                       Bitmap bmp = BitmapFactory.decodeByteArray(data, 0, data.length);
                       image.setImageBitmap(bmp);
                   }
               });
           }
       });
   }

对于图片下载，文件下载其实是类似的；图片下载是通过回调的Response拿到byte[]然后decode成图片；文件下载则是拿到inputStream做写文件操作，我们这里就不赘述了。

3. okHttp网络请求之封装

如果每次请求网络都需要写重复的代码绝对是令人头疼的，网上也有很多对OkHttp封装的优秀开源项目，譬如OkHttpUtils，封装的意义就在于更加方便的使用，具有拓展性，但是对OkHttp封装最需要解决的是以下的两点：

避免重复代码调用
将请求结果回调改为UI线程

根据以上两点，我也做一个简单的封装，首先呢我们写一个抽象类用于请求回调：

public interface ReqCallBack {
    /**响应成功*/
     void onReqSuccess(T result);
    /**响应失败*/
     void onReqFailed(String errorMsg);
}

接下来创建一个OkHttpManager类封装OkHttp，并实现了异步GET请求：

  public class OkHttpManager {
        private static volatile OkHttpManager mInstance;//单例引用
        private OkHttpClient mOkHttpClient;//okHttpClient实例
        private Handler okHttpHandler;//全局处理子线程和主线程通信

        /**
         * 初始化OkHttpManager
         */
        public OkHttpManager(Context context) {
            //初始化OkHttpClient
            mOkHttpClient = new OkHttpClient().newBuilder()
                    .connectTimeout(10, TimeUnit.SECONDS)//设置超时时间
                    .readTimeout(10, TimeUnit.SECONDS)//设置读取超时时间
                    .writeTimeout(10, TimeUnit.SECONDS)//设置写入超时时间
                    .build();
            //初始化Handler
            okHttpHandler = new Handler(context.getMainLooper());
        }

        /**
         * 获取单例引用
         */    
        public static OkHttpManager getInstance(Context context) {
            if (mInstance == null) {
                synchronized (OkHttpManager.class) {
                    if (mInstance == null) {
                        mInstance = new OkHttpManager(context);
                    }
                }
            }
            return mInstance;
        }

        /**
         * okHttp get异步请求
         * @param actionUrl 接口地址
         * @param callBack 请求返回数据回调
         * @param  数据泛型
         * @return
         */
        public  Call getAsynHttp(String url, final ReqCallBack callBack) {
            try {
                final Request request = new Request.Builder()
                        .url(url)
                        .build();
                Call call = mOkHttpClient.newCall(request);
                call.enqueue(new Callback() {
                    @Override
                    public void onFailure(Call call, IOException e) {
                        failedCallBack("访问失败", callBack);
                    }

                    @Override
                    public void onResponse(Call call, Response response) throws IOException {
                        if (response.isSuccessful()) {
                            String string = response.body().string();
                            successCallBack((T) string, callBack);
                        } else {
                            failedCallBack("服务器错误", callBack);
                        }
                    }
                });
                return call;
            } catch (Exception e) {}
            return null;
        }

        /**
         * 统一处理成功信息
         * @param result
         * @param callBack
         * @param 
         */
        private  void successCallBack(final T result, final ReqCallBack callBack) {
            okHttpHandler.post(new Runnable() {
                @Override
                public void run() {
                    if (callBack != null) {
                        callBack.onReqSuccess(result);
                    }
                }
            });
        }

        /**
         * 统一处理失败信息
         * @param errorMsg
         * @param callBack
         * @param 
         */
        private  void failedCallBack(final String errorMsg, final ReqCallBack callBack) {
            okHttpHandler.post(new Runnable() {
                @Override
                public void run() {
                    if (callBack != null) {
                        callBack.onReqFailed(errorMsg);
                    }
                }
            });
        }       
   }

最后使用这个OkHttpManager来请求网络：

OkHttpManager.getInstance(this).getAsynHttp("http://www.baidu.com", new ReqCallBack() {
          @Override
          public void onReqSuccess(String result) {
              Toast.makeText(getApplicationContext(), result, Toast.LENGTH_SHORT).show();
          }

          @Override
          public void onReqFailed(String errorMsg) {
              showlog(errorMsg);
          }          
       });

是不是很简单呢？就几句代码就实现了GET请求，而且请求结果回调是在UI线程的。这里只是一个很简单的封装例子，如果用在正式项目里推荐OkHttpUtils。

4. okHttp网络请求之Json解析

一般情况下服务端默认返回的是Json字符串，上面通过封装我们直接将Json返回给客户端。其实封装内部还能通过GSON解析让客户端直接获取对象。
首先新建两个Bean文件：

public class Weather {
    public WeatherInfo weatherinfo;
}

public class WeatherInfo {
    public String city;
    public String cityid;
    public String date_y;
    public String temp1;
    public String weather1;

    public String toString() {
        return "[city:"+city+" cityid:"+cityid+" date_y:"+date_y+" temp1:"+temp1+" weather1:"+weather1+"]";
    }
}

改写上面的OkHttpManager，在服务器端成功返回Json后做一次转换，将Json字符串转换成Weather对象：

@Override
public void onResponse(Call call, Response response) throws IOException {
       if (response.isSuccessful()) {
             String string = response.body().string();
             Weather weather = new Gson().fromJson(string, Weather.class);
             successCallBack((T) weather, callBack);
       } else {
             failedCallBack("服务器错误", callBack);
       }
}

请求网络，这里泛型类型我们传入Weather：

OkHttpManager.getInstance(this).getAsynHttp("http://weather.51wnl.com/weatherinfo/GetMoreWeather?cityCode=101020100&weatherType=0", new ReqCallBack() {
          @Override
          public void onReqSuccess(Weather weather) {
              WeatherInfo weatherInfo = weather.weatherinfo;
              showlog(weatherInfo.toString());
          }

          @Override
          public void onReqFailed(String errorMsg) {
              showlog(errorMsg);
          }          
       });

可以看到，这里返回的已经是Weather对象了。注意，在正式项目里对OkHttp做封装时要考虑全面，对传进来的不同类型要生成不同的对象，而不仅仅是这里的Weather。

5. okHttp网络请求之自定义Interceptor

我们可以通过自定义Interceptor来实现很多操作,打印日志,缓存,重试等等。
要实现自己的拦截器需要有以下步骤
(1) 需要实现Interceptor接口，并复写intercept(Chain chain)方法,返回response
(2) Request 和 Response的Builder中有header,addHeader,headers方法,需要注意的是使用header有重复的将会被覆盖,而addHeader则不会。
标准的 Interceptor写法：

public class OAuthInterceptor implements Interceptor {

  private final String username;
  private final String password;

  public OAuthInterceptor(String username, String password) {
    this.username = username;
    this.password = password;
  }

  @Override public Response intercept(Chain chain) throws IOException {

    String credentials = username + ":" + password;

    String basic = "Basic " + Base64.encodeToString(credentials.getBytes(), Base64.NO_WRAP);

    Request originalRequest = chain.request();
    String cacheControl = originalRequest.cacheControl().toString();

    Request.Builder requestBuilder = originalRequest.newBuilder()
        //Basic Authentication,也可用于token验证,OAuth验证
        .header("Authorization", basic)
        .header("Accept", "application/json")
        .method(originalRequest.method(), originalRequest.body());

    Request request = requestBuilder.build();

    Response originalResponse = chain.proceed(request);
    Response.Builder responseBuilder =
        //Cache control设置缓存
        originalResponse.newBuilder().header("Cache-Control", cacheControl);

    return responseBuilder.build();
  }
}

6. okHttp网络请求之缓存控制Cache-Control

使用缓存可以让我们的app不用长时间地显示令人厌烦的加载圈，提高了用户体验，而且还节省了流量，在数据更新不是很频繁的地方使用缓存就非常有必要了。想要加入缓存不需要我们自己来实现，Okhttp已经内置了缓存，默认是不使用的，如果想使用缓存我们需要手动设置。
设置缓存就需要用到OkHttp的interceptors，缓存的设置需要靠请求和响应头。如果想要弄清楚缓存机制，则需要了解一下HTTP语义，其中控制缓存的就是Cache-Control字段，OkHttp3中有一个Cache类是用来定义缓存的，此类详细介绍了几种缓存策略,具体可看此类源码。

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

服务器支持缓存
如果服务器支持缓存，请求返回的Response会带有这样的Header:Cache-Control, max-age=xxx,这种情况下我们只需要手动给okhttp设置缓存就可以让okhttp自动帮你缓存了。这里的max-age的值代表了缓存在你本地存放的时间，可以根据实际需要来设置其大小。
首先我们要提供了一个文件路径用来存放缓存，另外还需要指定缓存的大小就可以创建一个缓存了。

File sdcache = getExternalCacheDir();
int cacheSize = 10 * 1024 * 1024;
Cache cache = new Cache(sdcache.getAbsoluteFile(), cacheSize);

创建了这个缓存后我们还需要将其设置到okttpClient对象里面：

OkHttpClient mOkHttpClient = new OkHttpClient().newBuilder()
              .cache(cache)
              .connectTimeout(20, TimeUnit.SECONDS)
              .readTimeout(20, TimeUnit.SECONDS)
              .build();

服务器不支持缓存
如果服务器不支持缓存就可能没有指定这个头部，或者指定的值是如no-store等，但是我们还想在本地使用缓存的话要怎么办呢？这种情况下我们就需要使用Interceptor来重写Respose的头部信息，从而让okhttp支持缓存。
如下所示，我们重写的Response的Cache-Control字段：

public class CacheInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = chain.proceed(request);
        return response.newBuilder()
                .removeHeader("Pragma")
                .removeHeader("Cache-Control")
                //cache for 30 days
                .header("Cache-Control", "max-age=" + 3600 * 24 * 30) 
                .build();
    }
}

然后将该Intercepter作为一个NetworkInterceptor加入到okhttpClient中：

OkHttpClient okHttpClient = new OkHttpClient();
OkHttpClient mOkHttpClient = okHttpClient.newBuilder()
        .addNetworkInterceptor(new CacheInterceptor())
        .cache(cache)
        .connectTimeout(20, TimeUnit.SECONDS)
        .readTimeout(20, TimeUnit.SECONDS)
        .build();

Request request = new Request.Builder()
                 .url("http://www.baidu.com")
                 .build();
         Call call = mOkHttpClient.newCall(request);
         call.enqueue(new Callback() {
             @Override
             public void onFailure(Call call, IOException e) {}

             @Override
             public void onResponse(Call call, final Response response) throws IOException {
                 if (null != response.cacheResponse()) {
                     String str = response.cacheResponse().toString();
                     showlog("cache--->" + str);
                 } else {
                     response.body().string();
                     String str=response.networkResponse().toString();
                     showlog("network--->" + str);
                 }
                 runOnUiThread(new Runnable() {
                     @Override
                     public void run() {
                         Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
                     }
                 });
             }
         });

这样我们就可以在服务器不支持缓存的情况下使用缓存了。第一次请求会请求网络得到数据，第二次以及后面的请求则会从缓存中取出数据：

当然也有种情况是有的请求每次都需要最新的数据，则在创建Request，来设置cacheControl为“CacheControl.FORCE_NETWORK”，用来表示请求会一直请求网络得到数据：

final Request request = new Request.Builder()
                .url("http://www.baidu.com")
                .cacheControl(CacheControl.FORCE_NETWORK)
                .build();

可以看到每次返回结果都来自网络。
两个CacheControl常量介绍：

CacheControl.FORCE_CACHE; //仅仅使用缓存
CacheControl.FORCE_NETWORK;//仅仅使用网络

但是大家必须注意一点，okhttp的缓存设计和浏览器的一样，是用来提升用户体验降低服务器负荷的，比如：我们在有网的时候也会先调用缓存，但是有个时间限制，例如1分钟之内，有网和没有网都是先读缓存，这个可以参考下面讲解的第一种类型。
如果你想要做成那种离线可以缓存，在线就获取最新数据的功能，可以参考第二种类型。

第一种类型（有网和没有网都是先读缓存）

1、创建拦截器：

Interceptor interceptor = new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Response response = chain.proceed(request);
            String cacheControl = request.cacheControl().toString();
            if (TextUtils.isEmpty(cacheControl)) {
                cacheControl = "public, max-age=60";
            }
            return response.newBuilder()
                    .header("Cache-Control", cacheControl)
                    .removeHeader("Pragma")
                    .build();
        }
    };

设置max-age为60s之后，这60s之内不管你有没有网,都读缓存。如果cache没有过期会直接返回cache而不会发起网络请求，若过期会自动发起网络请求。

2、设置client

/**创建OkHttpClient，并添加拦截器和缓存代码**/
OkHttpClient client = new OkHttpClient.Builder()
          .addNetworkInterceptor(interceptor)
          .cache(cache).build();

第二种类型（离线可以缓存，在线就获取最新数据）

这种方法和第一种方法的区别是在设置的拦截器上，这里同时使用NetworkInterceptor和AppInterceptor。
先讲一下步骤：
1、首先，给OkHttp设置拦截器
2、然后，在拦截器内做Request拦截操作，在每个请求发出前，判断一下网络状况，如果没问题继续访问，如果有问题，则设置从本地缓存中读取
3、接下来是设置Response，先判断网络，网络好的时候，移除header后添加cache失效时间为0小时，网络未连接的情况下设置缓存时间为4周

代码：
1、给OkHttp设置拦截器（用Interceptor）

OkHttpClient client = new OkHttpClient.Builder()
         .addNetworkInterceptor(interceptor)
         .addInterceptor(interceptor)
         .cache(cache).build();

2、Request拦截操作

Request request = chain.request();
/**注意：如果您使用FORCE_CACHE和网络的响应需求，OkHttp则会返回一个504提示，告诉你不可满足请求响应。所以我们加一个判断在没有网络的情况下使用*/
if (!isNetworkAvailable(MainActivity.this)) {
            request = request.newBuilder()
                        .cacheControl(CacheControl.FORCE_CACHE) //无网络时，强制从缓存取
                        .build();
            showlog("no network");
}

3、设置Response

Response response = chain.proceed(request);
if (isNetworkAvailable(MainActivity.this)) {
           int maxAge = 0 * 60; // 有网络时，设置缓存超时时间0个小时
           showlog("has network maxAge="+maxAge);
           response.newBuilder()
                   .header("Cache-Control", "public, max-age=" + maxAge)
                   .removeHeader("Pragma")// 清除头信息，因为服务器如果不支持，会返回一些干扰信息，不清除下面无法生效
                   .build();
} else {
           showlog("network error");
           int maxStale = 60 * 60 * 24 * 28; // 无网络时，设置超时为4周
           showlog("has maxStale="+maxStale);
           response.newBuilder()
                   .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                   .removeHeader("Pragma")
                   .build();
          showlog("response build maxStale="+maxStale);
 }
 return response;

查看缓存文件：
运行程序，在Android/data/com.hx.okhttp.cache下会发现很多缓存文件，这些缓存文件全是以url的md5加密字段为文件名，每一个response分两个文件保存，以.0和.1结尾的文件区分。进去看里面的内容如下： .0的文件里面是header，而.1文件里面是返回的具体内容，即json数据。

分别看一下内容吧：

因为百度html页面含有中文，这里看到数据有乱码现象

注意的是：okhttp只会对get请求进行缓存，post请求是不会进行缓存，这也是有道理的，因为get请求的数据一般是比较持久的，而post一般是交互操作，没太大意义进行缓存。

7. okHttp取消请求

使用call.cancel()可以立即停止掉一个正在执行的call。如果一个线程正在写请求或者读响应，将会引发IOException。当用户离开一个应用时或者跳到其他界面时，使用Call.cancel()可以节约网络资源，另外不管同步还是异步的call都可以取消。
也可以通过tags来同时取消多个请求。当你构建一请求时，使用RequestBuilder.tag(tag)来分配一个标签。之后你就可以用OkHttpClient.cancel(tag)来取消所有带有这个tag的call。
为了模拟这个场景我们首先创建一个定时的线程池：

private ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

private  void cancelCall(){
        OkHttpClient mOkHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url("http://www.baidu.com")
                .cacheControl(CacheControl.FORCE_NETWORK)
                .build();
        Call call = null;
        call = mOkHttpClient.newCall(request);
        final Call finalCall = call;
        //100毫秒后取消call
        executor.schedule(new Runnable() {
            @Override 
            public void run() {
                finalCall.cancel();
            }
        }, 100, TimeUnit.MILLISECONDS);

        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {}

            @Override
            public void onResponse(Call call,final Response response) {
                if (null != response.cacheResponse()) {
                    String str = response.cacheResponse().toString();
                    showlog("cache--->" + str);
                } else {
                    try {
                        response.body().string();
                    } catch (IOException e) {
                        showlog("IOException");
                        e.printStackTrace();
                    }
                    String str = response.networkResponse().toString();
                    showlog("network--->" + str);
                }
            }
        });
        showlog("是否取消成功"+call.isCanceled());
    }

100毫秒后调用call.cancel()，为了能让请求耗时，我们设置每次请求都要请求网络，运行程序并且不断的快速点击发送请求按钮：

很明显每次cancel()都失败了，仍旧成功的访问了网络。每隔100毫秒来调用call.cancel()显然时间间隔太长，这段时间网络已经返回了数据，我们设置为1毫秒并不断的快速的点击发送请求按钮：

这次每次cancel()操作都成功了。

Demo下载地址

OkHttpUtils封装类

1.支持的常用功能

一般的 get,post,put,delete,head,options请求
基于Post的大文本数据上传，postString(),postJson()等
多文件和多参数统一的表单上传（允许监听上传进度）
支持一个key上传一个文件，也可以一个Key上传多个文件
大文件下载和下载进度回调
大文件上传和上传进度回调
支持cookie的内存存储和持久化存储，支持传递自定义cookie
提供网络缓存功能，默认支持304缓存协议，并额外扩展了三种本地缓存模式
支持301、302重定向
支持链式调用
支持可信证书和自签名证书的https访问
注：对https访问不了解的童鞋推荐去看hongyang大神的文章：Android Https相关完全解析当OkHttp遇到Https
支持根据Tag取消网络请求
支持自定义泛型Callback，自动根据泛型返回对象

2.支持的扩展功能

统一的文件下载管理（DownloadManager）
默认使用的是 get 请求，同时下载数量为3个，支持断点下载，断点信息使用ORMLite数据库框架保存，默认下载路径/storage/emulated/0/download，下载路径和下载数量都可以在代码中配置，下载管理使用了服务提高线程优先级，避免后台下载时被系统回收。
当你的项目需要做大量的下载的时候，并且多个页面需要监听下载进度，使用该扩展让你更方便。原生支持下载任务的开始、暂停、停止、出错、完成五个状态，当同时下载任务数量超过3个（可代码动态设置）时，后续任务自动等待，当有任务下载完成时，等待任务按照优先级自动开始下载。
统一的文件上传管理（UploadManager）
默认使用的是 post 上传请求，该上传管理为简单管理，不支持断点续传和分片上传，只是简单的将所有上传任务使用线程池进行了统一管理，默认同时上传数量为1个。由于断点分片上传的技术需要大量的服务端代码配合，同时也会极大的增加客户端代码量，所以综合考虑，该框架不做实现。如果确实有特殊需要，可以自己做扩展。

3.OkHttpUtils的优势

优势一：性能高，专注于简单易用的网络请求，使用主流的okhttp进行封装，对于okhttp大家都知道，在Android4.4的源码中可以看到HttpURLConnection已经替换成OkHttp实现了，并且支持HTTP2/SPDY黑科技，支持socket自动选择最好路线，并支持自动重连，拥有自动维护的socket连接池，减少握手次数，拥有队列线程池，轻松写并发。
优势二：特有的网络缓存模式，是大多数网络框架所不具备的，说一个应用场景，老板说我们的app不仅需要在有网的情况下展示最新的网络数据，还要在没网的情况下使用缓存数据，这时候是不是项目中出现了大量的代码判断当前网络状况，根据不同的状态保存不同的数据，然后决定是否使用缓存。细想一下，这是个通用的写法，于是OkHttpUtils提供了四种缓存模式，让你不用关心缓存的实现，而专注于数据的处理。
优势三：方便易用的扩展接口，可以添加全局的公共参数，全局拦截器，全局超时时间，更可以对单个请求定制拦截器，超时时间，请求参数修改等等，在使用上更是方便，原生支持的链式调用让你的请求更加清晰。
优势四：强大的Cookie保持策略，我们知道在客户端对cookie的获取是个不太简单的事情，特别是还要处理cookie的过期时间，持久化策略等等，OkHttpUtils帮你彻底解决Cookie的难题，默认拥有内存存储和持久化存储两种实现，cookie全程自动管理，并且提供了额外的addCookie方式，允许介入到自动管理的过程中，添加你想创建的任何cookie。

4.使用方法

Eclipse的用户，导入JAR包或添加依赖工程：
见我后面的Demo，用得是依赖工程。

添加网络访问权限和读写SD卡权限：

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

5.使用注意事项

okhttputils使用的okhttp的版本是最新的 3.2.0 版本，和以前的 2.x 的版本可能会存在冲突。
okhttpserver是对okhttputils的扩展，统一了下载管理和上传管理，对项目有需要做统一下载的可以考虑使用该扩展，不需要的可以直接使用okhttputils即可。
对于缓存模式使用，需要与返回对象相关的所有javaBean必须实现Serializable接口，否者会报NotSerializableException。
使用缓存时，如果不指定cacheKey，默认是用url带参数的全路径名为cacheKey。
使用该网络框架时，必须要在 Application 中做初始化 OkHttpUtils.init(this);。

6.全局配置

一般在 Aplication，或者基类中，只需要调用一次即可，可以配置调试开关，全局的超时时间，公共的请求头和请求参数等信息，所有的请求参数都支持中文。

    @Override
    public void onCreate() {
        super.onCreate();

        //---------这里给出的是示例代码,告诉你可以这么传,实际使用的时候,根据需要传,不需要就不传-------------//
        HttpHeaders headers = new HttpHeaders();
        headers.put("commonHeaderKey1", "commonHeaderValue1");    //header不支持中文
        headers.put("commonHeaderKey2", "commonHeaderValue2");
        HttpParams params = new HttpParams();
        params.put("commonParamsKey1", "commonParamsValue1");     //param支持中文,直接传,不要自己编码
        params.put("commonParamsKey2", "这里支持中文参数");
        //-----------------------------------------------------------------------------------//

        //必须调用初始化
        OkHttpUtils.init(this);

        //以下设置的所有参数是全局参数,同样的参数可以在请求的时候再设置一遍,那么对于该请求来讲,请求中的参数会覆盖全局参数
        //好处是全局参数统一,特定请求可以特别定制参数
        try {
            //以下都不是必须的，根据需要自行选择,一般来说只需要 debug,缓存相关,cookie相关的 就可以了
            OkHttpUtils.getInstance()
                    //打开该调试开关,控制台会使用 红色error 级别打印log,并不是错误,是为了显眼,不需要就不要加入该行
                    .debug("OkHttpUtils")
                    //如果使用默认的 60秒,以下三行也不需要传
                    .setConnectTimeout(OkHttpUtils.DEFAULT_MILLISECONDS)  //全局的连接超时时间
                    .setReadTimeOut(OkHttpUtils.DEFAULT_MILLISECONDS)     //全局的读取超时时间
                    .setWriteTimeOut(OkHttpUtils.DEFAULT_MILLISECONDS)    //全局的写入超时时间
                    //可以全局统一设置缓存模式,默认是不使用缓存,可以不传
                    .setCacheMode(CacheMode.NO_CACHE)
                    //可以全局统一设置缓存时间,默认永不过期
                    .setCacheTime(CacheEntity.CACHE_NEVER_EXPIRE)
                    //如果不想让框架管理cookie,以下不需要
//                  .setCookieStore(new MemoryCookieStore()) //cookie使用内存缓存（app退出后，cookie消失）
                    .setCookieStore(new PersistentCookieStore()) //cookie持久化存储，如果cookie不过期，则一直有效

                    //可以设置https的证书,以下几种方案根据需要自己设置
//                    .setCertificates()                                  //方法一：信任所有证书（选一种即可）
//                    .setCertificates(getAssets().open("srca.cer"))      //方法二：也可以自己设置https证书（选一种即可）
//                    .setCertificates(getAssets().open("aaaa.bks"), "123456", getAssets().open("srca.cer"))//方法三：传入bks证书,密码,和cer证书,支持双向加密

                    //可以添加全局拦截器,不会用的千万不要传,错误写法直接导致任何回调不执行
//                .addInterceptor(new Interceptor() {
//                    @Override
//                    public Response intercept(Chain chain) throws IOException {
//                        return chain.proceed(chain.request());
//                    }
//                })

                    //这两行同上,不需要就不要传
                    .addCommonHeaders(headers)                                         //设置全局公共头
                    .addCommonParams(params);                                          //设置全局公共参数
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

7.普通Http请求

1.基本的网络请求

请求String：

OkHttpUtils.get("http://www.baidu.com")  // 请求方式和请求url
        .tag(this)  // 请求的 tag, 主要用于取消对应的请求
        .cacheKey("cacheKey") // 设置当前请求的缓存key,建议每个不同功能的请求设置不同值，防止覆盖
        .cacheMode(CacheMode.DEFAULT) // 缓存模式，详细请看缓存介绍
        .execute(new StringCallback() {
                    @Override
                    public void onSuccess(String t, Call call, Response response) {
                        showlog("t =" + t); 
                        showHeader(call, response);
                    }
        });

注意：这里我们将request和response的头部信息用log打印出来了：

   public void showHeader(Call call, Response response){
       /**request*/
       showlog(call.request().toString());
       /**request请求头信息*/
       Headers requestHeadersString = call.request().headers();
       Set requestNames = requestHeadersString.names();
       StringBuilder sb = new StringBuilder();
       for (String name : requestNames) {
           sb.append(name).append(" ： ").append(requestHeadersString.get(name)).append("\n");
       }
       showlog(sb.toString());
       /**response*/
       showlog(response.toString());
       /**response响应头信息*/
       Headers responseHeadersString = response.headers();
       Set responseNames = responseHeadersString.names();
       StringBuilder sb1 = new StringBuilder();
       for (String name : responseNames) {
           sb1.append(name).append(" ： ").append(requestHeadersString.get(name)).append("\n");
       }
       showlog(sb1.toString());
   }

请求Json：

OkHttpUtils.get("http://weather.51wnl.com/weatherinfo/GetMoreWeather?cityCode=101020100&weatherType=0")
              .tag(this)
              .cacheKey("cacheKey2") // 设置当前请求的缓存key,建议每个不同功能的请求设置不同值，防止覆盖
              .cacheMode(CacheMode.DEFAULT) // 缓存模式，详细请看缓存介绍
              .execute(new JsonCallback(Weather.class) {
                @Override
                public void onSuccess(Weather weather, Call call, Response response) {
                    showHeader(call, response);
                    WeatherInfo weatherInfo = weather.weatherinfo;
                    showlog("city is " + weatherInfo.city);
                    showlog("cityid is " + weatherInfo.cityid);
                    showlog("date_y is " + weatherInfo.date_y);
                    showlog("temp1 is " + weatherInfo.temp1);
                    showlog("weather1 is " + weatherInfo.weather1);             
                }
        });

注意：这里请求Json返回的是Weather对象，因为添加到了缓存，所以Weather必须实现Serializable接口，否者会报NotSerializableException。
来看看Weather的Bean文件写法：

public class Weather implements Serializable {
    private static final long serialVersionUID = 1L;
    public WeatherInfo weatherinfo;
}

public class WeatherInfo implements Serializable{
    private static final long serialVersionUID = 1L;
    public String city;
    public String cityid;
    public String date_y;
    public String temp1;
    public String weather1;
}

2.请求 Bitmap 对象

        OkHttpUtils.get("https://img-my.csdn.net/uploads/201309/01/1378037128_5291.jpg")
                .tag(this)
                .execute(new BitmapCallback(){
                    @Override
                    public void onSuccess(Bitmap t, Call call, Response response) {
                        showHeader(call, response);
                        image.setImageBitmap(t);
                    }                   
                });

3.请求文件下载

OkHttpUtils.get("https://img-my.csdn.net/uploads/201308/31/1377949598_9982.jpg")
    .tag(this)
    //文件下载时，需要指定下载的文件目录和文件名
    .execute(new FileCallback("/sdcard/temp/", "file.jpg") {  
            @Override
            public void onSuccess(File file, Call call, Response response) {
            showHeader(call, response);}

            @Override
            public void downloadProgress(long currentSize, long totalSize, float progress, long networkSpeed) {
                String downloadLength = Formatter.formatFileSize(getApplicationContext(), currentSize);
                String totalLength = Formatter.formatFileSize(getApplicationContext(), totalSize);
                size.setText(downloadLength + "/" + totalLength);
                String netSpeed = Formatter.formatFileSize(getApplicationContext(), networkSpeed);
                speed.setText(netSpeed + "/S");
                percent.setText((Math.round(progress * 10000) * 1.0f / 100) + "%");
                progressBar.setMax(100);
                progressBar.setProgress((int) (progress * 100));
            }
    });

4.Post上传文件
可以使用的方式有一个key对应一个文件和一个key对应多个文件。注意，在这里上传之前需要在/sdcard/temp路径下存在file.jpg和file2.jpg两个文件。

        ArrayList files = new ArrayList();
        files.add(new File("/sdcard/temp/file1.jpg"));
        files.add(new File("/sdcard/temp/file2.jpg"));
        // 拼接参数
        OkHttpUtils.post("http://server.jeasonlzy.com/OkHttpUtils/upload")
                .tag(this)
                .headers("header1", "headerValue1")
                .headers("header2", "headerValue2")
                .params("param1", "paramValue1")
                .params("param2", "paramValue2")
                //这种方式为一个key，对应一个文件
            /** .params("file1",new File("文件路径")) 
                .params("file2",new File("文件路径")) */
                // 这种方式为同一个key，上传多个文件
                .addFileParams("file", files) 
                .execute(new JsonCallback(ServerModel.class) {
                    @Override
                    public void onSuccess(ServerModel model, Call call, Response response) {
                        showHeader(call, response);
                        showlog(model.toString());
                    }

                    @Override
                    public void upProgress(long currentSize, long totalSize, float progress, long networkSpeed) {
                        String downloadLength = Formatter.formatFileSize(getApplicationContext(), currentSize);
                        String totalLength = Formatter.formatFileSize(getApplicationContext(), totalSize);
                        size.setText(downloadLength + "/" + totalLength);
                        String netSpeed = Formatter.formatFileSize(getApplicationContext(), networkSpeed);
                        speed.setText(netSpeed + "/S");
                        percent.setText((Math.round(progress * 10000) * 1.0f / 100) + "%");
                        progressBar.setMax(100);
                        progressBar.setProgress((int) (progress * 100));
                    }
                });

6.请求功能的所有配置讲解
以下代码包含了以下内容：

一次普通请求所有能配置的参数，真实使用时不需要配置这么多，按自己的需要选择性的使用即可
多文件和多参数的表单上传，同时支持进度监听
自签名网站https的访问，调用setCertificates方法即可
为单个请求设置超时，比如涉及到文件的需要设置读写等待时间多一点。
Cookie一般情况下只需要在初始化的时候调用setCookieStore即可实现cookie的自动管理，如果特殊业务需要，需要手动额外向服务器传递自定义的cookie，可以在每次请求的时候调用addCookie方法，该方法提供了3个重载形式，可以根据自己的需要选择使用。

/**
 * 该类的回调具有如下顺序,虽然顺序写的很复杂,但是理解后,是很简单,并且合情合理的
 * 
1.无缓存模式{@link CacheMode#NO_CACHE}
 * ---网络请求成功  onBefore -> parseNetworkResponse -> onSuccess -> onAfter
 * ---网络请求失败  onBefore -> parseNetworkFail     -> onError   -> onAfter
 * 
2.默认缓存模式,遵循304头{@link CacheMode#DEFAULT}

 * ---网络请求成功,服务端返回非304  onBefore -> parseNetworkResponse -> onSuccess -> onAfter
 * ---网络请求成功服务端返回304    onBefore -> onCacheSuccess       -> onAfter
 * ---网络请求失败               onBefore -> parseNetworkFail     -> onError   -> onAfter
 * 
3.请求网络失败后读取缓存{@link CacheMode#REQUEST_FAILED_READ_CACHE}
 * ---网络请求成功,不读取缓存    onBefore -> parseNetworkResponse -> onSuccess -> onAfter
 * ---网络请求失败,读取缓存成功  onBefore -> parseNetworkFail -> onError -> onCacheSuccess -> onAfter
 * ---网络请求失败,读取缓存失败  onBefore -> parseNetworkFail -> onError -> onCacheError   -> onAfter
 * 
4.如果缓存不存在才请求网络，否则使用缓存{@link CacheMode#IF_NONE_CACHE_REQUEST}
 * ---已经有缓存,不请求网络  onBefore -> onCacheSuccess -> onAfter
 * ---没有缓存请求网络成功   onBefore -> onCacheError   -> parseNetworkResponse -> onSuccess -> onAfter

 * ---没有缓存请求网络失败   onBefore -> onCacheError   -> parseNetworkFail     -> onError   -> onAfter

 * 5.先使用缓存，不管是否存在，仍然请求网络{@link CacheMode#FIRST_CACHE_THEN_REQUEST}

 * ---无缓存时,网络请求成功  onBefore -> onCacheError   -> parseNetworkResponse -> onSuccess -> onAfter
 * ---无缓存时,网络请求失败  onBefore -> onCacheError   -> parseNetworkFail     -> onError   -> onAfter
 * ---有缓存时,网络请求成功  onBefore -> onCacheSuccess -> parseNetworkResponse -> onSuccess -> onAfter
 * ---有缓存时,网络请求失败  onBefore -> onCacheSuccess -> parseNetworkFail     -> onError   -> onAfter
 */

OkHttpUtils.get(Urls.URL_METHOD) // 请求方式和请求url, get请求不需要拼接参数，支持get，post，put，delete，head，options请求
    .tag(this)               // 请求的 tag, 主要用于取消对应的请求
    .connTimeOut(10000)      // 设置当前请求的连接超时时间
    .readTimeOut(10000)      // 设置当前请求的读取超时时间
    .writeTimeOut(10000)     // 设置当前请求的写入超时时间
    .cacheKey("cacheKey")    // 设置当前请求的缓存key,建议每个不同功能的请求设置一个
    .cacheMode(CacheMode.FIRST_CACHE_THEN_REQUEST) // 缓存模式，详细请看第四部分，缓存介绍
    .setCertificates(getAssets().open("srca.cer")) // 自签名https的证书，可变参数，可以设置多个
    .addInterceptor(interceptor)            // 添加自定义拦截器
    .headers("header1", "headerValue1")     // 添加请求头参数
    .headers("header2", "headerValue2")     // 支持多请求头参数同时添加
    .params("param1", "paramValue1")        // 添加请求参数
    .params("param2", "paramValue2")        // 支持多请求参数同时添加
    .params("file1", new File("filepath1")) // 可以添加文件上传
    .params("file2", new File("filepath2")) // 支持多文件同时添加上传
    .addUrlParams("key", List values)  //这里支持一个key传多个参数
    .addFileParams("key", List files)    //这里支持一个key传多个文件
    .addFileWrapperParams("key", List fileWrappers) //这里支持一个key传多个文件
    .addCookie("aaa", "bbb")                // 这里可以传递自己想传的Cookie
    .addCookie(cookie)                      // 可以自己构建cookie
    .addCookies(cookies)                    // 可以一次传递批量的cookie
     //这里给出的泛型为 RequestInfo，同时传递一个泛型的 class对象，即可自动将数据结果转成对象返回
    .execute(new DialogCallback(this, RequestInfo.class) {
        @Override
        public void onBefore(BaseRequest request) {
            // UI线程 请求网络之前调用
            // 可以显示对话框，添加/修改/移除 请求参数
        }

        @Override
        public RequestInfo parseNetworkResponse(Response response) throws Exception{
            // 子线程，可以做耗时操作
            // 根据传递进来的 response 对象，把数据解析成需要的 RequestInfo 类型并返回
            // 可以根据自己的需要，抛出异常，在onError中处理
            return null;
        }

        @Override
        public void onResponse(boolean isFromCache, RequestInfo requestInfo, Request request, @Nullable Response response) {
            // UI 线程，请求成功后回调
            // isFromCache 表示当前回调是否来自于缓存
            // requestInfo 返回泛型约定的实体类型参数
            // request     本次网络的请求信息，如果需要查看请求头或请求参数可以从此对象获取
            // response    本次网络访问的结果对象，包含了响应头，响应码等，如果数据来自于缓存，该对象为null
        }

        @Override
        public void onError(boolean isFromCache, Call call, @Nullable Response response, @Nullable Exception e) {
            // UI 线程，请求失败后回调
            // isFromCache 表示当前回调是否来自于缓存
            // call        本次网络的请求对象，可以根据该对象拿到 request
            // response    本次网络访问的结果对象，包含了响应头，响应码等，如果网络异常 或者数据来自于缓存，该对象为null
            // e           本次网络访问的异常信息，如果服务器内部发生了错误，响应码为 400~599之间，该异常为 null
        }

        @Override
        public void onAfter(boolean isFromCache, @Nullable RequestInfo requestInfo, Call call, @Nullable Response response, @Nullable Exception e) {
            // UI 线程，请求结束后回调，无论网络请求成功还是失败，都会调用，可以用于关闭显示对话框
            // isFromCache 表示当前回调是否来自于缓存
            // requestInfo 返回泛型约定的实体类型参数，如果网络请求失败，该对象为　null
            // call        本次网络的请求对象，可以根据该对象拿到 request
            // response    本次网络访问的结果对象，包含了响应头，响应码等，如果网络异常 或者数据来自于缓存，该对象为null
            // e           本次网络访问的异常信息，如果服务器内部发生了错误，响应码为 400~599之间，该异常为 null
        }

        @Override
        public void upProgress(long currentSize, long totalSize, float progress, long networkSpeed) {
            // UI 线程，文件上传过程中回调，只有请求方式包含请求体才回调（GET,HEAD不会回调）
            // currentSize  当前上传的大小（单位字节）
            // totalSize 　 需要上传的总大小（单位字节）
            // progress     当前上传的进度，范围　0.0f ~ 1.0f
            // networkSpeed 当前上传的网速（单位秒）
        }

        @Override
        public void downloadProgress(long currentSize, long totalSize, float progress, long networkSpeed) {
            // UI 线程，文件下载过程中回调
            //参数含义同　上传相同
        }
    });

7.取消请求
每个请求前都设置了一个参数tag，取消则通过OkHttpUtils.cancel(tag)执行。例如：在Activity中，当Activity销毁取消请求，可以在onDestory里面统一取消。

@Override
    protected void onDestroy() {
        super.onDestroy();
        //根据 Tag 取消请求
        OkHttpUtils.getInstance().cancelTag(this);
    }

8.同步的请求
execute方法不传入callback即为同步的请求，返回Response对象，需要自己解析

Response response = OkHttpUtils.get("http://www.baidu.com")
            .tag(this)
            .headers("aaa", "111")
            .params("bbb", "222")
            .execute();

8.自定义CallBack使用

目前内部提供的包含AbsCallback, StringCallBack ,BitmapCallback ,FileCallBack ,可以根据自己的需求去自定义Callback

AbsCallback: 所有回调的父类，抽象类
StringCallBack：如果返回值类型是纯文本数据，即可使用该回调
BitmapCallback：如果请求的是图片数据，则可以使用该回调
FileCallBack：如果要做文件下载，则必须使用该回调，内部封装了关于文件下载进度回调的方法

该网络框架的核心使用方法即为Callback的继承使用。因为不同的项目需求，可能对数据格式进行了不同的封装，于是在 Demo 中的进行了详细的代码示例，以下是详细介绍：

CommonCallback:继承自AbsCallback,主要作用是做全局共同请求参数的添加，同样也可以在第一步全局配置的时候设置，效果一样。
EncryptCallback：继承自CommonCallback,主要功能是做 Url
参数加密，对每个请求的参数进行编码，防止拦截数据包，篡改数据。
JsonCallback：继承自EncryptCallback,一般来说，服务器返回的响应码都包含 code，msg，data
三部分，在此根据自己的业务需要完成相应的逻辑判断，并对数据进行解析，可以使用 Gson 或者 fastjson，将解析的对象返回。
DialogCallback：继承自JsonCallback,对需要在网络请求的时候显示对话框，使用该回调。
StringDialogCallback：继承自EncryptCallback,如果网络返回的数据只是纯文本，使用该回调
BitmapDialogCallback ：继承自BitmapCallback,如果网络返回的是Bitmap对象，使用该回调
DownloadFileCallBack ：继承自FileCallback,如果需要做文件下载，使用该回调

9.缓存的使用

使用缓存前，必须让缓存的数据javaBean对象实现Serializable接口，否者会报NotSerializableException。因为缓存的原理是将对象序列化后直接写入数据库中，如果不实现Serializable接口，会导致对象无法序列化，进而无法写入到数据库中，也就达不到缓存的效果。

目前提供了四种CacheMode缓存模式：

DEFAULT: 按照HTTP协议的默认缓存规则，例如有304响应头时缓存
REQUEST_FAILED_READ_CACHE：先请求网络，如果请求网络失败，则读取缓存，如果读取缓存失败，本次请求失败。该缓存模式的使用，会根据实际情况，导致onResponse,onError,onAfter三个方法调用不只一次，具体请在三个方法返回的参数中进行判断。
IF_NONE_CACHE_REQUEST：如果缓存不存在才请求网络，否则使用缓存。
FIRST_CACHE_THEN_REQUEST：先使用缓存，不管是否存在，仍然请求网络，如果网络顺利，会导致onResponse方法执行两次，第一次isFromCache为true，第二次isFromCache为false。使用时根据实际情况，对onResponse,onError,onAfter三个方法进行具体判断。

注：无论对于哪种缓存模式，都可以指定一个cacheKey，建议针对不同需要缓存的页面设置不同的cacheKey，如果相同，会导致数据覆盖。

10. 统一的文件下载管理（DownloadManager）

下载任务的管理

/** 添加一个下载任务,taskTag用来标识每一个下载任务，fileName默认为null */
public void addTask(String taskTag, BaseRequest request, DownloadListener listener);
/** 添加一个下载任务,taskTag用来标识每一个下载任务，fileName指定文件名 */
public void addTask(String fileName, String taskTag, BaseRequest request, DownloadListener listener);    
 /** 开始所有任务 */
public void startAllTask();
/** 暂停 */
public void pauseTask(String taskKey);
/** 暂停全部任务 */
public void pauseAllTask();
/** 停止 */
public void stopTask(String taskKey);
/** 停止全部任务 */
public void stopAllTask();
/** 删除一个任务,不会删除下载文件 */
public void removeTask(String taskKey);
/** 删除一个任务,会删除下载文件 */
public void removeTask(String taskKey, boolean isDeleteFile);
/** 删除所有任务 */
public void removeAllTask();
/** 重新下载 */
public void restartTask(String taskKey);
/** 重新开始下载任务 */
private void restartTaskByKey(String taskKey);
/** 获取一个任务 */
public DownloadInfo getDownloadInfo(String taskKey);
/** 移除一个任务 */
private void removeTaskByKey(String taskKey);

添加一个下载任务

    public void downloadFile(String url) {
        if (downloadManager.getDownloadInfo(url) != null) {
            Toast.makeText(getApplicationContext(), "任务已经在下载列表中", Toast.LENGTH_SHORT).show();
        } else {
            GetRequest request = OkHttpUtils.get(url)
                    .headers("headerKey1", "headerValue1")
                    .headers("headerKey2", "headerValue2")
                    .params("paramKey1", "paramValue1")
                    .params("paramKey2", "paramValue2");
            downloadManager.addTask(url, request, null);
        }
    }

更新下载进度
首先获取所有下载信息的列表：

List allTask = downloadManager.getAllTask();

在Adapter的getView中我们获取当前下载信息，对每个DownloadInfo设置一个下载监听器：

        @Override
        public View getView(final int position, View convertView, ViewGroup parent) {
            DownloadInfo downloadInfo = allTask.get(position);
            ViewHolder holder;
            if (convertView == null) {
                convertView = View.inflate(DownloadManagerActivity.this, R.layout.item_download_manager, null);
                holder = new ViewHolder(convertView);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();
            }
            holder.refresh(downloadInfo);

            /**对于非进度更新的ui放在这里，对于实时更新的进度ui，放在holder中*/
            holder.name.setText(downloadInfo.getFileName());
            holder.download.setOnClickListener(holder);
            holder.remove.setOnClickListener(holder);
            holder.restart.setOnClickListener(holder);
           /** 给每一个downloadInfo设置下载监听器downloadListener*/
            DownloadListener downloadListener = new MyDownloadListener();
            downloadListener.setUserTag(holder);
            downloadInfo.setListener(downloadListener);
            return convertView;
        }

重写监听器DownloadListener方法：

    private class MyDownloadListener extends DownloadListener {
        @Override
        public void onProgress(DownloadInfo downloadInfo) {
            if (getUserTag() == null) return;
            ViewHolder holder = (ViewHolder) getUserTag(); //根据downloadInfo获取holder
            holder.refresh(); //每次进度更新回调触发holder的refresh
        }

        @Override
        public void onFinish(DownloadInfo downloadInfo) {
            Toast.makeText(DownloadManagerActivity.this, "下载完成:" + downloadInfo.getTargetPath(), Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onError(DownloadInfo downloadInfo, String errorMsg, Exception e) {
            if (errorMsg != null) Toast.makeText(DownloadManagerActivity.this, errorMsg, Toast.LENGTH_SHORT).show();
        }
    }

在holder的refresh方法中更新下载进度：

private class ViewHolder implements View.OnClickListener {
        private DownloadInfo downloadInfo;
        private TextView name;
        private TextView downloadSize;
        private TextView tvProgress;
        private TextView netSpeed;
        private ProgressBar pbProgress;
        private Button download;
        private Button remove;
        private Button restart;

        public ViewHolder(View convertView) {
            name = (TextView) convertView.findViewById(R.id.name);
            downloadSize = (TextView) convertView.findViewById(R.id.downloadSize);
            tvProgress = (TextView) convertView.findViewById(R.id.tvProgress);
            netSpeed = (TextView) convertView.findViewById(R.id.netSpeed);
            pbProgress = (ProgressBar) convertView.findViewById(R.id.progress);
            download = (Button) convertView.findViewById(R.id.start);
            remove = (Button) convertView.findViewById(R.id.remove);
            restart = (Button) convertView.findViewById(R.id.restart);
        }

        public void refresh(DownloadInfo downloadInfo) {
            this.downloadInfo = downloadInfo;
            refresh();
        }

        /**对于实时更新的进度ui，放在这里，例如进度的显示，而图片加载等，不要放在这，会不停的重复回调，也会导致内存泄漏*/
        private void refresh() {
            String downloadLength = Formatter.formatFileSize(DownloadManagerActivity.this, downloadInfo.getDownloadLength());
            String totalLength = Formatter.formatFileSize(DownloadManagerActivity.this, downloadInfo.getTotalLength());
            downloadSize.setText(downloadLength + "/" + totalLength);
            if (downloadInfo.getState() == DownloadManager.NONE) {
                netSpeed.setText("停止");
                download.setText("下载");
            } else if (downloadInfo.getState() == DownloadManager.PAUSE) {
                netSpeed.setText("暂停中");
                download.setText("继续");
            } else if (downloadInfo.getState() == DownloadManager.ERROR) {
                netSpeed.setText("下载出错");
                download.setText("出错");
            } else if (downloadInfo.getState() == DownloadManager.WAITING) {
                netSpeed.setText("等待中");
                download.setText("等待");
            } else if (downloadInfo.getState() == DownloadManager.FINISH) {
                netSpeed.setText("下载完成");
            } else if (downloadInfo.getState() == DownloadManager.DOWNLOADING) {
                String networkSpeed = Formatter.formatFileSize(DownloadManagerActivity.this, downloadInfo.getNetworkSpeed());
                netSpeed.setText(networkSpeed + "/s");
                download.setText("暂停");
            }
            tvProgress.setText((Math.round(downloadInfo.getProgress() * 10000) * 1.0f / 100) + "%");
            pbProgress.setMax((int) downloadInfo.getTotalLength());
            /**更新进度显示*/
            pbProgress.setProgress((int) downloadInfo.getDownloadLength());
        }

        @Override
        public void onClick(View v) {
            if (v.getId() == download.getId()) {
                switch (downloadInfo.getState()) {
                    case DownloadManager.PAUSE:
                    case DownloadManager.NONE:
                    case DownloadManager.ERROR:
                        downloadManager.addTask(downloadInfo.getUrl(), downloadInfo.getRequest(), downloadInfo.getListener());
                        break;
                    case DownloadManager.DOWNLOADING:
                        downloadManager.pauseTask(downloadInfo.getUrl());
                        break;
                    case DownloadManager.FINISH:
                        break;
                }
                refresh();
            } else if (v.getId() == remove.getId()) {
                downloadManager.removeTask(downloadInfo.getUrl());
                adapter.notifyDataSetChanged();
            } else if (v.getId() == restart.getId()) {
                downloadManager.restartTask(downloadInfo.getUrl());
            }
        }
    }

11. 统一的文件上传管理（UploadManager）

上传任务的管理

/** 添加一个上传任务,默认使用post请求 */
public  void addTask(String url, File resource, String key, UploadListener listener) {
        PostRequest request = OkHttpUtils.post(url).params(key, resource);
        addTask(url, request, listener);
    }
/** 添加一个上传任务 */
public  void addTask(String taskKey, BaseBodyRequest request, UploadListener listener);
/**获取所有的上传任务*/
public List getAllTask();

添加上传任务

public void uploadFiles(){
        if (images != null) {
            for (int i = 0; i < images.size(); i++) {
                MyUploadListener listener = new MyUploadListener();
               //给每个listener设置一个tag值，就是listview的子View
               listener.setUserTag(listView.getChildAt(i));
                PostRequest postRequest = OkHttpUtils.post("http://server.jeasonlzy.com/OkHttpUtils/upload")
                        .headers("headerKey1", "headerValue1")
                        .headers("headerKey2", "headerValue2")
                        .params("paramKey1", "paramValue1")
                        .params("paramKey2", "paramValue2")
                        .params("fileKey" + i, new File(images.get(i)));
                uploadManager.addTask(images.get(i), postRequest, listener);
            }
        }
    }

注意：这里上传路径下必须存在对应的文件，否则上传时会走到监听器的onError方法。

更新上传进度
从上面看出，添加上传任务时，每个任务传入一个监听器：

...
MyUploadListener listener = new MyUploadListener();
...
uploadManager.addTask(images.get(i), postRequest, listener);

我们重写的UploadListener类：

    private class MyUploadListener extends UploadListener {
        private ViewHolder holder;

        @Override
        public void onProgress(UploadInfo uploadInfo) {
            //通过子View的getTag获取holder
            holder = (ViewHolder) ((View) getUserTag()).getTag();
            //每次进度更新回调触发holder的refresh
            holder.refresh(uploadInfo);
        }

        @Override
        public void onFinish(String s) {
            Log.e("MyUploadListener", "finish:" + s);
            holder.finish();
        }

        @Override
        public void onError(UploadInfo uploadInfo, String errorMsg, Exception e) {
            Log.e("MyUploadListener", "onError:" + errorMsg);
        }

        @Override
        public String parseNetworkResponse(Response response) throws Exception {
            Log.e("MyUploadListener", "parseNetworkResponse");
            return response.body().string();
        }
    }

在holder的refresh中刷新当前上传的状态值和上传进度：

        public void refresh(UploadInfo uploadInfo) {
            if (uploadInfo.getState() == DownloadManager.NONE) {
                status.setText("请上传");
                percent.setText("请上传");
            } else if (uploadInfo.getState() == UploadManager.ERROR) {
                status.setText("上传出错");
                percent.setText("错误");
            } else if (uploadInfo.getState() == UploadManager.WAITING) {
                status.setText("等待中");
                percent.setText("等待");
            } else if (uploadInfo.getState() == UploadManager.FINISH) {
                status.setText("上传成功");
                percent.setText("成功");
            } else if (uploadInfo.getState() == UploadManager.UPLOADING) {
                status.setText("上传中");
                percent.setText((Math.round(uploadInfo.getProgress() * 10000) * 1.0f / 100) + "%");  //更新上传进度
            }
        }

OkHttpUtils Demo下载地址

OkHttp源码分析

上面是OKHttp总体设计图，主要是通过Diapatcher不断从RequestQueue中取出请求（Call），根据是否已缓存调用Cache或Network这两类数据获取接口之一，从内存缓存或是服务器取得请求的数据。该引擎有同步和异步请求，同步请求通过Call.execute()直接返回当前的Response，而异步请求会把当前的请求Call.enqueue添加（AsyncCall）到请求队列中，并通过回调（Callback）的方式来获取最后结果。
调用execute方法会立即执行我们的请求,execute()的代码逻辑如下：

public Response execute() throws IOException {  
    synchronized (this) { 
    //判断是否已经执行过，如果已经执行了则直接抛出异常，也就是说一个Call实例只能调用一次execute方法 
      if (executed) throw new IllegalStateException("Already Executed");  
      executed = true;  
    }  
    try {  
      //立即把本次Call放入已知双端行队列中      
      client.getDispatcher().executed(this);  
      //调用getResponseWithInterceptorChain
      Response result = getResponseWithInterceptorChain(false);  
      if (result == null) throw new IOException("Canceled");  
      return result;  
    } finally {  
      //从执行完成队列中移除  
      client.getDispatcher().finished(this);  
    }  
  }

调用enqueue方法执行代码逻辑如下：

public void enqueue(Callback responseCallback) {  
   enqueue(responseCallback, false);  
 }  

 void enqueue(Callback responseCallback, boolean forWebSocket) {  
   synchronized (this) {  
     //同样的也进行了判断本次Call是否是第一次调用
     if (executed) throw new IllegalStateException("Already Executed");  
     executed = true;  
   }  
   //调用enqueue(AsyncCall call)进行入队操作
   client.getDispatcher().enqueue(new AsyncCall(responseCallback, forWebSocket));  
 }

可以看到最终的请求是dispatcher来完成的。Dispatcher主要用于控制并发的请求，它主要维护了以下变量：

  /** 最大并发请求数*/
  private int maxRequests = 64;
  /** 每个主机最大请求数*/
  private int maxRequestsPerHost = 5;
  /** 消费者线程池 */
  private ExecutorService executorService;
  /** 将要运行的异步请求队列 */
  private final Deque readyAsyncCalls = new ArrayDeque<>();
  /**正在运行的异步请求队列 */
  private final Deque runningAsyncCalls = new ArrayDeque<>();
  /** 正在运行的同步请求队列 */
  private final Deque runningSyncCalls = new ArrayDeque<>();

接下来看一下入队函数：

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }

当正在运行的异步请求队列中的数量小于64并且正在运行的请求主机数小于5时则把请求加载到runningAsyncCalls中并在线程池中执行，否则就再入到readyAsyncCalls中进行缓存等待。
AsyncCall 是Call的内部类，final修饰，继承了NamedRunnable,而NamedRunnable 实现了Runnable接口，可以指定线程的名称。NamedRunnbale提供了一个抽象方法execute()来供AsyncCall 实现，我们看下AsyncCall 的实现逻辑：

@Override protected void execute() {  
      boolean signalledCallback = false;  
      try {  
   //同样调用getResponseWithInterceptorChain方法来获取Response对象  
        Response response = getResponseWithInterceptorChain(forWebSocket);  
        if (canceled) {  
          signalledCallback = true;  
          //取消执行的时候调用  
          responseCallback.onFailure(originalRequest, new IOException("Canceled"));  
        } else {  
          signalledCallback = true;  
          //执行成功的回调  
          responseCallback.onResponse(response);  
        }  
      } catch (IOException e) {  
        if (signalledCallback) {  
          // Do not signal the callback twice!  
          logger.log(Level.INFO, "Callback failure for " + toLoggableString(), e);  
        } else {  
          //网络请求失败的时候  
          responseCallback.onFailure(engine.getRequest(), e);  
        }  
      } finally {  
       //从dispatcher删除本次Call  
        client.getDispatcher().finished(this);  
      }  
    }  
  }

当AsyncCall中的execute执行的时候，代码会走到finally块，OkHttpClient 调用getDispatcher()方法获取Dispathcer对象，然后调用finished方法。下面我们看一下finished方法里面的代码逻辑：

synchronized void finished(AsyncCall call) {  
//从正在执行队列中移除本次Call    
   if (!runningCalls.remove(call)) throw new AssertionError("AsyncCall wasn't running!");  
   ///把准备队列中的请求加入到执行队列中,并且执行其他请求  
   promoteCalls();  
 }

finished方法将此次请求从runningAsyncCalls移除后还执行了promoteCalls方法：

//把准备队列中的请求加入到执行队列中,并且执行其他请求  
  private void promoteCalls() {  
    //判断是否超过了最大的请求数量(默认为64个)    
    if (runningCalls.size() >= maxRequests) return; // Already running max capacity.  
    if (readyCalls.isEmpty()) return; // No ready calls to promote.  
    //遍历准备队列  
    for (Iterator i = readyCalls.iterator(); i.hasNext(); ) {  
      AsyncCall call = i.next();  
      if (runningCallsForHost(call) < maxRequestsPerHost) {  
        i.remove();  
        //把准备队列中的请求加入到执行队列中  
        runningCalls.add(call);  
        //调用线程池，执行本次线线程  
        getExecutorService().execute(call);  
      }  
      //执行队列已经满了,不再添加执行任务。  
      if (runningCalls.size() >= maxRequests) return; // Reached max capacity.  
    }  
  }

可以看到最关键的点就是会从readyAsyncCalls取出下一个请求，并加入runningAsyncCalls中并交由线程池处理。
好了让我们再回到上面的AsyncCall的execute方法，我们会发现OkHttpClient同步请求和异步请求调用的接口不一样，但它们最后都是殊途同归地走到Call里面的getResponseWithInterceptorChain，很明显这是在请求网络。

private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException {  
    //实例化一个拦截器  
    Interceptor.Chain chain = new ApplicationInterceptorChain(0, originalRequest, forWebSocket);  
    //调用proceed方法获取Response对象  
    return chain.proceed(originalRequest);  
  }

创建了一个ApplicationInterceptorChain ，并且第一个参数传入0，这个0是有特殊用法的，涉及到OKHttp里面的一个功能叫做拦截器，从getResponseWithInterceptorChain这个名字里其实也能看出一二。先看看proceed做了什么：

@Override public Response proceed(Request request) throws IOException {  
     //是否有请求之前的拦截器,如果有先执行拦截器  
     if (index < client.interceptors().size()) {  
       // There's another interceptor in the chain. Call that.  
       Interceptor.Chain chain = new ApplicationInterceptorChain(index + 1, request, forWebSocket);  
       return client.interceptors().get(index).intercept(chain);  
     } else {  
       // No more interceptors. Do HTTP.  
    //当前没有拦截器，调用getResponse方法返回Response对象  
       return getResponse(request, forWebSocket);  
     }  
   }

proceed方法每次从拦截器列表中取出拦截器，当存在多个拦截器时都会在第6行阻塞，并等待下一个拦截器的调用返回。下面分别以拦截器链中有1个、2个拦截器的场景加以模拟：

注：这里碰到一个拦截器，OKHttp增加了一个拦截器机制，拦截器主要用来观察，修改以及可能拦截请求输出和响应的回来。通常情况下拦截器用来添加，移除或者转换请求或者响应的头部信息。来看看官方文档里提供的例子
首先自定义一个拦截器用于打印一些发送信息

class LoggingInterceptor implements Interceptor {
  @Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();

    long t1 = System.nanoTime();
    logger.info(String.format("Sending request %s on %s%n%s", request.url(), chain.connection(), request.headers()));

    Response response = chain.proceed(request);
    long t2 = System.nanoTime();
    logger.info(String.format("Received response for %s in %.1fms%n%s", response.request().url(), (t2 - t1) / 1e6d, response.headers()));

    return response;
  }
}

然后使用的时候把它添加到okhttpclient

OkHttpClient client = new OkHttpClient();
client.interceptors().add(new LoggingInterceptor());

Request request = new Request.Builder()
    .url("http://www.publicobject.com/helloworld.txt")
    .header("User-Agent", "OkHttp Example")
    .build();

Response response = client.newCall(request).execute();
response.body().close();

当我们执行到proceed，就会去判断是否有拦截器有的话先执行拦截器里的intercept，而在intercept里一般会进行一些自定义操作并且调用procced去判断是否要继续执行拦截器操作还是直接去获取网络请求，上面的例子执行结果如下:

INFO: Sending request http://www.publicobject.com/helloworld.txt on null
User-Agent: OkHttp Example

INFO: Received response for https://publicobject.com/helloworld.txt in 1179.7ms
Server: nginx/1.4.6 (Ubuntu)
Content-Type: text/plain
Content-Length: 1759
Connection: keep-alive

拦截器的整个机制如下图

上图中把拦截器分为应用拦截器和网络拦截器，其实这个取决于你在拦截器里做了哪方面的操作，比如改变请求头部之类的就可以使用网络拦截器。
在处理完拦截器操作后，就进入到重要的getResponse方法，真正的去进行发送请求，处理请求，接收返回结果。

Response getResponse(Request request, boolean forWebSocket) throws IOException {  
    // Copy body metadata to the appropriate request headers.  
    //post有http请求body  
    RequestBody body = request.body();  
    if (body != null) {  
      //完善http请求头信息添加Content-Type,Content-Length      
      Request.Builder requestBuilder = request.newBuilder();  
      MediaType contentType = body.contentType();  
      if (contentType != null) {  
        requestBuilder.header("Content-Type", contentType.toString());  
      }  
      //获取请求body的长度  
      long contentLength = body.contentLength();  
      if (contentLength != -1) {  
         //body长度确定 一次性发送给服务器  
        requestBuilder.header("Content-Length", Long.toString(contentLength));  
        requestBuilder.removeHeader("Transfer-Encoding");  
      } else {  
         //body长度不确定设置标记为Transfer-Encoding：chunked  
        requestBuilder.header("Transfer-Encoding", "chunked");  
        requestBuilder.removeHeader("Content-Length");  
      }  
      request = requestBuilder.build();  
    }  
    // Create the initial HTTP engine. Retries and redirects need new engine for each attempt.  
    //初始化Http 引擎,重新连接，重定向都需要一个新的引擎。  
    engine = new HttpEngine(client, request, false, false, forWebSocket, null, null, null, null);  
    //记录重新请求的次数  
    int followUpCount = 0;  
    while (true) {  
      //是否已经取消执行  
      if (canceled) {  
        //释放连接  
        engine.releaseConnection();  
        throw new IOException("Canceled");  
      }  
      try {  
        //发起请求  
        engine.sendRequest();  
        //获取响应  
        engine.readResponse();  
      } catch (RequestException e) {  
        // The attempt to interpret the request failed. Give up.  
        throw e.getCause();  
      } catch (RouteException e) {  
        // The attempt to connect via a route failed. The request will not have been sent.  
        //路由失败,视图重新构建HttpEngine进行连接  
        HttpEngine retryEngine = engine.recover(e);  
        if (retryEngine != null) {  
          //如果恢复过来重新发送请求,重新获取response对象  
          engine = retryEngine;  
          continue;  
        }  
        // Give up; recovery is not possible.  
        throw e.getLastConnectException();  
      } catch (IOException e) {  
        // An attempt to communicate with a server failed. The request may have been sent.  
        //网络连接失败从新获取连接  
        HttpEngine retryEngine = engine.recover(e, null);  
        if (retryEngine != null) {  
          //如果恢复过来重新发送请求,重新获取response对象  
          engine = retryEngine;  
          continue;  
        }  
        // Give up; recovery is not possible.  
        //抛出异常 无法重新连接  
        throw e;  
      }  
      //获取响应  
      Response response = engine.getResponse();  
      //获取重新请求对象  
      Request followUp = engine.followUpRequest();  
      //重新发情请求对象为空,说明无需重新构建请求，直接返回响应对象response  
      if (followUp == null) {  
        //没有采用websocket，无需进维护连接,释放连接  
        if (!forWebSocket) {  
        //释放连接  
          engine.releaseConnection();  
        }  
        //返回response退出循环  
        return response;  
      }  
      //如果重连的次数超过最大连接数这里默认是20,则抛出异常  
      if (++followUpCount > MAX_FOLLOW_UPS) {  
        throw new ProtocolException("Too many follow-up requests: " + followUpCount);  
      }  
      if (!engine.sameConnection(followUp.httpUrl())) {  
        engine.releaseConnection();  
      }  
      Connection connection = engine.close();  
      request = followUp;  
      //从新构建http引擎  
      engine = new HttpEngine(client, request, false, false, forWebSocket, connection, null, null,  
          response);  
    }  
  }

代码比较多，看重点，可以看到如果是post请求，先做一定的头部处理，然后新建一个HttpEngine去处理具体的操作，通过sendRequest发送具体请求操作，readResponse对服务器的答复做一定处理，在代码70行处getResponse得到从服务器返回的Response。我们先来看看sendRequest方法：

public void sendRequest() throws RequestException, RouteException, IOException {
    if (cacheStrategy != null) return; // Already sent.
    if (httpStream != null) throw new IllegalStateException();
    //请求头部添加
    Request request = networkRequest(userRequest);
    //获取client中的Cache,同时Cache在初始化的时候会去读取缓存目录中关于曾经请求过的所有信息。
    InternalCache responseCache = Internal.instance.internalCache(client);
    //cacheCandidate为上次与服务器交互缓存的Response
    Response cacheCandidate = responseCache != null
        ? responseCache.get(request)
        : null;

    long now = System.currentTimeMillis();

    //创建CacheStrategy.Factory对象，进行缓存配置
    cacheStrategy = new CacheStrategy.Factory(now, request, cacheCandidate).get();
    //网络请求
    networkRequest = cacheStrategy.networkRequest;
    //缓存的响应
    cacheResponse = cacheStrategy.cacheResponse;

    if (responseCache != null) {
     //记录当前请求是网络发起还是缓存发起
      responseCache.trackResponse(cacheStrategy);
    }

    if (cacheCandidate != null && cacheResponse == null) {
      closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
    }

    //不进行网络请求并且缓存不存在或者过期则返回504错误
    if (networkRequest == null && cacheResponse == null) {
      userResponse = new Response.Builder()
          .request(userRequest)
          .priorResponse(stripBody(priorResponse))
          .protocol(Protocol.HTTP_1_1)
          .code(504)
          .message("Unsatisfiable Request (only-if-cached)")
          .body(EMPTY_BODY)
          .build();
      return;
    }

    // 不进行网络请求，而且缓存可以使用，直接返回缓存
    if (networkRequest == null) {
      userResponse = cacheResponse.newBuilder()
          .request(userRequest)
          .priorResponse(stripBody(priorResponse))
          .cacheResponse(stripBody(cacheResponse))
          .build();
      userResponse = unzip(userResponse);
      return;
    }

    //需要访问网络时
    boolean success = false;
    try {
      httpStream = connect();
      httpStream.setHttpEngine(this);

      if (writeRequestHeadersEagerly()) {
        long contentLength = OkHeaders.contentLength(request);
        if (bufferRequestBody) {
          if (contentLength > Integer.MAX_VALUE) {
            throw new IllegalStateException("Use setFixedLengthStreamingMode() or "
                + "setChunkedStreamingMode() for requests larger than 2 GiB.");
          }

          if (contentLength != -1) {
            // Buffer a request body of a known length.
            httpStream.writeRequestHeaders(networkRequest);
            requestBodyOut = new RetryableSink((int) contentLength);
          } else {
            // Buffer a request body of an unknown length. Don't write request headers until the
            // entire body is ready; otherwise we can't set the Content-Length header correctly.
            requestBodyOut = new RetryableSink();
          }
        } else {
          httpStream.writeRequestHeaders(networkRequest);
          requestBodyOut = httpStream.createRequestBody(networkRequest, contentLength);
        }
      }
      success = true;
    } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (!success && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
    }
  }

上面的代码显然是在发送请求，但是最主要的是做了缓存的策略。cacheCandidate是上次与服务器交互缓存的Response，这里的缓存都是基于Map，key是请求中url的md5，value是在文件中查询到的缓存，页面置换基于LRU算法，我们现在只需要知道它是一个可以读取缓存Header的Response即可。根据cacheStrategy的处理得到了networkRequest和cacheResponse这两个值，根据这两个值的数据是否为null来进行进一步的处理，当networkRequest和cacheResponse都为null的情况也就是不进行网络请求并且缓存不存在或者过期，这时候则返回504错误；当networkRequest 为null时也就是不进行网络请求，而且缓存可以使用时则直接返回缓存；其他的情况则请求网络。
接下来我们查看readResponse方法：

public void readResponse() throws IOException {
    ...省略
    else{
      //读取网络响应
      networkResponse = readNetworkResponse();
    }
    //将响应头部存入Cookie中
    receiveHeaders(networkResponse.headers());

    // If we have a cache response too, then we're doing a conditional get.
    if (cacheResponse != null) {
    //检查缓存是否可用，如果可用。那么就用当前缓存的Response，关闭网络连接，释放连接。
      if (validate(cacheResponse, networkResponse)) {
        userResponse = cacheResponse.newBuilder()
            .request(userRequest)
            .priorResponse(stripBody(priorResponse))
            .headers(combine(cacheResponse.headers(), networkResponse.headers()))
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
        networkResponse.body().close();
        releaseStreamAllocation();

        // Update the cache after combining headers but before stripping the
        // Content-Encoding header (as performed by initContentStream()).
        InternalCache responseCache = Internal.instance.internalCache(client);
        responseCache.trackConditionalCacheHit();
        // 更新缓存
        responseCache.update(cacheResponse, stripBody(userResponse));
        userResponse = unzip(userResponse);
        return;
      } else {
        closeQuietly(cacheResponse.body());
      }
    }

    userResponse = networkResponse.newBuilder()
        .request(userRequest)
        .priorResponse(stripBody(priorResponse))
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();

    if (hasBody(userResponse)) {
      maybeCache();
      userResponse = unzip(cacheWritingResponse(storeRequest, userResponse));
    }
  }

这个方法发起刷新请求头部和请求体，解析HTTP响应头部。如果有缓存并且可用则用缓存的数据并更新缓存，否则就用网络请求返回的数据。
我们再来看看validate(cacheResponse, networkResponse)方法是如何判断缓存是否可用的：

private static boolean validate(Response cached, Response network) {
  //如果服务器返回304则缓存有效
    if (network.code() == HTTP_NOT_MODIFIED) {
      return true;
    }
   //通过缓存和网络请求响应中的Last-Modified来计算是否是最新数据，如果是则缓存有效
    Date lastModified = cached.headers().getDate("Last-Modified");
    if (lastModified != null) {
      Date networkLastModified = network.headers().getDate("Last-Modified");
      if (networkLastModified != null
          && networkLastModified.getTime() < lastModified.getTime()) {
        return true;
      }
    }
    return false;
  }

如缓存果过期或者强制放弃缓存，在此情况下，缓存策略全部交给服务器判断，客户端只用发送条件get请求即可，如果缓存是有效的，则返回304 Not Modifiled，否则直接返回body。条件get请求有两种方式一种是Last-Modified-Date，一种是 ETag。这里采用了Last-Modified-Date，通过缓存和网络请求响应中的Last-Modified来计算是否是最新数据，如果是则缓存有效。
最后我们再回到它的getResponse方法

Response getResponse(Request request, boolean forWebSocket) throws IOException {
  ...省略
      boolean releaseConnection = true;
      try {
        engine.sendRequest();
        engine.readResponse();
        releaseConnection = false;
      } catch (RequestException e) {
        // The attempt to interpret the request failed. Give up.
        throw e.getCause();
      } catch (RouteException e) {
        // The attempt to connect via a route failed. The request will not have been sent.
        HttpEngine retryEngine = engine.recover(e.getLastConnectException(), null);
        if (retryEngine != null) {
          releaseConnection = false;
          engine = retryEngine;
          continue;
        }
        // Give up; recovery is not possible.
        throw e.getLastConnectException();
      } catch (IOException e) {
        // An attempt to communicate with a server failed. The request may have been sent.
        HttpEngine retryEngine = engine.recover(e, null);
        if (retryEngine != null) {
          releaseConnection = false;
          engine = retryEngine;
          continue;
        }

        // Give up; recovery is not possible.
        throw e;
      } finally {
        // We're throwing an unchecked exception. Release any resources.
        if (releaseConnection) {
          StreamAllocation streamAllocation = engine.close();
          streamAllocation.release();
        }
      }
     ...省略
      engine = new HttpEngine(client, request, false, false, forWebSocket, streamAllocation, null,
          response);
    }
  }

查看代码第11行和21行当发生IOException或者RouteException时会执行HttpEngine的recover方法：

 public HttpEngine recover(IOException e, Sink requestBodyOut) {
    if (!streamAllocation.recover(e, requestBodyOut)) {
      return null;
    }

    if (!client.retryOnConnectionFailure()) {
      return null;
    }

    StreamAllocation streamAllocation = close();

    // For failure recovery, use the same route selector with a new connection.
    return new HttpEngine(client, userRequest, bufferRequestBody, callerWritesRequestBody,
        forWebSocket, streamAllocation, (RetryableSink) requestBodyOut, priorResponse);
  }

最后一行可以看到就是重新创建了HttpEngine并返回，用来完成失败重连。
到这里OkHttp请求网络的流程基本上讲完了，下面是关于OKHttp的请求流程图：

延伸：
底层如何建立连接和服务器进行交互?

如何发送请求头?
如何发送请求体?
如何接受服务器响应?

这里要使用到一个关键的接口：Transport

可以看出该接口有两个实现类，一个是HttpTransport,支持用来http协议。另一个是FramedTransport用来支持spdy协议。该接口定义了一系列的方法来支持我们向服务器发送请求头、请求体、创建请求体等。
HttpTransport：

public HttpTransport(HttpEngine httpEngine, HttpConnection httpConnection) {  
  //传入HttpEngine 对象  
  this.httpEngine = httpEngine;  
  //传入HttpConnection 对象  
  this.httpConnection = httpConnection;  
}

FramedTransport：

public FramedTransport(HttpEngine httpEngine, FramedConnection framedConnection) {  
  //传入HttpEngine 对象  
  this.httpEngine = httpEngine;  
  //传入HttpConnection 对象  
  this.framedConnection = framedConnection;  
}

我们可以看到实际上Transport实现类的相关方法是调用HttpConnection(支持Http协议)或FramedConnection(支持spdy协议)来发送请求头、请求体、获取响应对象的。
OKHttpClient是一个基于java优秀的网络请求框架，

支持SPDY, 可以合并多个到同一个主机的请求
使用连接池技术减少请求的延迟(如果SPDY是可用的话)
使用GZIP压缩减少传输的数据量
缓存响应避免重复的网络请求

当你的网络出现拥挤的时候,就是OkHttp大显身手的时候, 它可以避免常见的网络问题,如果你的服务是部署在不同的IP上面的,如果第一个连接失败, OkHttp会尝试其他的连接. 这个对现在IPv4+IPv6中常见的把服务冗余部署在不同的数据中心上. OkHttp将使用现在TLS特性(SNI ALPN) 来初始化新的连接. 如果握手失败, 将切换到SLLv3使用OkHttp很容易, 同时支持异步阻塞请求和回调。我们可以结合自己的项目合理应用起来帮助我们构建健壮的应用程序。

你可能感兴趣的:(Android笔记)

Android笔记（六）（adb使用）张豆豆94 【Android学习笔记】android java 1024程序员节
1.添加环境变量此电脑（右击）→属性→高级系统设置→高级→环境变量→系统变量→Path（双击）→新建添加adb.exe路径2.adb常用指令adbdevices当前连接了几个设备以及每个连接的状态shell[]连接模拟器/设施执行Shell命令，执行完毕后退出远程Shell端ladbshellpmlistpackages列出手机装的所有app的包名查看内存查看磁盘内存和运行内存：adbshellf
19年开发搜集的资料与遇到的问题简单整理 4-6月 qq_40663451
Android笔记4-6月参考网站https://p.codekk.com/（开源代码、项目）https://blog.csdn.net/qq_42618969/article/details/81941242#开源框架框架帖子网址：https://blog.csdn.net/qq_35427437/article/details/80169160安卓十大开发框架1、AndBase框架项目地址：h
Android笔记（六）：JetPack Compose常见的UI组件灯前目力虽非昔，犹课蝇头二万言。 android 笔记 ui android compose
一、文本组件1.1TextColumn(modifier=Modifier.fillMaxSize().background(Color.Green).padding(10.dp)){Text(text=stringResource(id=R.string.title_content),modifier=Modifier.fillMaxWidth().border(BorderStroke(1.d
Android笔记编译kotlin文件 blossom_6694
一、下载编译包https://github.com/JetBrains/kotlin/releases/tag/v1.2.40TIM截图20180425120751.png然后解压。二、配置环境变量TIM截图20180425120911.png运行kotlinc-version成功，表示配置好了。三、编译TIM截图20180425121004.png
Android笔记：OpenGL ES与EGL的关系与实例 MichaelX_Blog Android OpenGL ES笔记 opengles egl 视频处理
简介OpenGL是跨平台的、专业的图形编程接口，而接口的实现是由厂商来完成的。OpenGL使用这些接口绘制完成后，需要把数据渲染到屏幕上，就需要EGL来接手这部分工作。EGL：全称EmbeddedGraphicLibrary。是OpenGLES和底层Native平台视窗系统之间的接口，如下图所示。EGL介绍EGL接口中含有3个对象，如下图所示：其中：Display(EGLDisplay)是对实际显
【Android笔记】 RecyclerView 小康
布局子布局bar_bundle_item.xmlpackagecom.example.meng.mes;publicclassBarJudgeActivityextendsAppCompatActivity{//捆号信息listprivateListbundleCodeInfoModelList=newArrayList{privateListmBundleCodeInfoModel;static
Android笔记（十九）：JetPack DataStore 之 Preferences DataStore 灯前目力虽非昔，犹课蝇头二万言。 android 笔记
JetpackDataStore是一种数据存储解决方案，主要适用于小型数据的处理。它可以通过协议缓冲区存储键值对或类型化对象。DataStore使用Kotlin协程和Flow以异步、一致的事务方式存储数据。DataStore有两种实现方式（1）PreferencesDataStore和（2）ProtoDataStore.PreferencesDataStore利用键值对实现对简单数据的读写存储。这
Android笔记（二十三）：Paging3分页加载库结合Compose的实现分层数据源访问灯前目力虽非昔，犹课蝇头二万言。 android 笔记 jvm
在Android笔记（二十二）：Paging3分页加载库结合Compose的实现网络单一数据源访问一文中，实现了单一数据源的访问。在实际运行中，往往希望不是单纯地访问网络数据，更希望将访问的网络数据保存到移动终端的SQLite数据库中，使得移动应用在离线的状态下也可以从数据库中获取数据进行访问。在本笔记中，将讨论多层次数据的访问，即结合网络资源+本地SQLite数据库中的数据的处理。在本笔记中，仍
Android笔记（二十二）：Paging3分页加载库结合Compose的实现网络单一数据源访问灯前目力虽非昔，犹课蝇头二万言。 android 笔记网络
Paging3组件是谷歌公司推出的分页加载库。个人认为Paging3库是非常强大，但是学习难点比较大的一个库。Paging3组件可用于加载和显示来自本地存储或网络中更大的数据集中的数据页面。此方法可让移动应用更高效地利用网络带宽和系统资源。在具体实现上，Paging3与前面的版本完全不同。一、依赖库的配置valpaging_version="3.2.0"implementation("androi
Android笔记（二十一）：Room组件实现Android应用的持久化处理灯前目力虽非昔，犹课蝇头二万言。 android 数据库 android JetPack Room组件
一、Room组件概述Room是AndroidJetPack架构组件之一，是一个持久处理的库。Room提供了在SQLite数据库上提供抽象层，使之实现数据访问。（1）实体类（Entity）：映射并封装了数据库对应的数据表中对应的结构化数据。实体定义了数据库中的数据表。实体类中的数据域与表的列一一对应。（2）数据访问对象（DataAccessObject，DAO）：在DAO中定义了访问数据库的常见的操
Android笔记——new Handler().postDelayed() 让intent延迟跳转麦香菌
longdelayMillis=2000;//延迟时间参数//延迟2s跳转newHandler().postDelayed(newRunnable(){@Overridepublicvoidrun(){Intentintent=newIntent(MainActivity.this,Activity.class);startActivity(intent);}},delayMillis);来源：《
Android笔记：SwipeRefreshLayout 自动刷新程思扬 Android 记录 android 笔记 python 经验分享 android-studio
/***TheSwipeRefreshLayoutshouldbeusedwhenevertheusercanrefreshthe*contentsofaviewviaaverticalswipegesture.Theactivitythat*instantiatesthisviewshouldaddanOnRefreshListenertobenotified*whenevertheswipet
Android笔记——自定义TabLayout之title与icon 麦香菌
自定义TabLayout自定义底端TabLayout总布局实现的是底端TabLayoutTabLayout自定义布局Selectorcoloricon因为三个图标的selector是一样的，所以就取了一个代码主要分以下两步实现，若想看怎么自定义，请直接跳到最后的getTabViewinitContent();initTab();String[]title={"个人","推荐","动态"};Cont
Android笔记：Android开发应用框架汇总（MVVP框架介绍）陈大宝 Android android mvp xml mvc ui
先来说一下常见的Android框架模式：MVC、MVP、MVVM这三种框架中，我们耳熟能详的就是MVC和MVP了吧，接下来我们简单介绍一下：MVCView：XML布局文件。Model：实体模型（数据的获取、存储、数据状态变化）。Controllor：对应于Activity，处理数据、业务和UI。从上面这个结构来看，Android本身的设计还是符合MVC架构的，但是Android中纯粹作为View的
Android笔记（十三）：结合JetPack Compose和CameraX实现视频的录制和存储灯前目力虽非昔，犹课蝇头二万言。 android 笔记音视频视频录制 CameraX
在“Android笔记（八）：基于CameraX库结合Compose和传统视图组件PreviewView实现照相机画面预览和照相功能”，文中介绍了拍照功能的实现，在本文中将介绍结合JetPackCompose和CameraX实现视频的录制。新建一个项目在项目中做如下处理：一、增视频录制的相关依赖库在项目的模块对应的build.gradle.kt中增加如下的依赖库：增加CameraX相关库valca
Android笔记（十五）：JetPack Compose的附带效应（二）-produceState和derivedStateOf 灯前目力虽非昔，犹课蝇头二万言。 android 笔记 Compose Compose的附带效应 produceState derivedStateOf
在本笔记中，将结合实例介绍produceState和derivedStateOf两个可组合函数。它们分别实现状态的转换。（1）produceState将非Compose状态转换虫Compose状态（2）derivedStateOf将多个状态转换成其他状态。一、produceStateproduceState可将非Compose状态转换为Compose状态，它会在没有定义数据源的情况下随时间生成值。
Android笔记（十四）：JetPack Compose中附带效应（一）灯前目力虽非昔，犹课蝇头二万言。 android 笔记 Compose的附带效应副效应带异步处理的副效应
在Android应用中可以通过定义可组合函数来搭建应用界面。应用界面的更新往往是与可组合函数内部定义的状态值相关联的。当界面的状态值发生变更，会导致应用界面进行更新。在Android笔记（九）：Compose组件的状态，对Compose组件的状态进行详细地介绍。理想状态下，可组合函数使用是定义范围内的状态值，通过内部状态的变更，修改可组合项构成的界面。但是，在有些特殊场景下，需要在可组合项中运行一
Android笔记： Android后台接口教程二Android 客户端与服务端交互Android 前后台通信 post方式陈大宝 Android android 数据库通信数据博客
今天再写一下post通信的方法，昨天的那篇是介绍了环境搭建还有最简单的get请求json数据，今天写了写登录功能，这两篇后台数据均是模拟的，没有数据库的交互，关于数据库交互后面再说。先看一下效果：用andorid写的一个小的demo结合接口完成了登录功能：登录失败登录成功下面来说代码部分：这篇就简单把核心功能说一下就好，有不懂的可以看昨天的那篇博客，传送地址http://blog.csdn.net
Android笔记之Android Studio获取数字签名猿小二 Android笔记
1.创建android可发布版本keybuild–>generatesignedapk–>createnew…没什么好说的，按照提示一步步完成最后在创建过程中设置的文件夹生成.jks文件2.使用的java的keytool命令获取数字证书内容，配置java环境变量后直接使用，未配置则使用keytool命令的全路径keytool-v-list-keystoreF:\xxx\xxx.jks
Android笔记（十）：结合Navigation组件实现Compose界面的导航灯前目力虽非昔，犹课蝇头二万言。 android 笔记 navigation组件 compose
在Android笔记（七）搭建AndroidJetPackCompose组件中Scaffold脚手架一文中通过定义一个导航的函数来实现不同界面的切换。如果没有传递任何参数，这样的导航处理也是可以接受的，处理方式也非常简单。但是，如果考虑到不同Compose界面的切换且传递参数，或者有更复杂地处理情况，就可以考虑使用导航组件Navigation来实现。一、导航组件的配置新建一个项目模块，在模块对应的
Android笔记（十一）：Compose中使用ViewModel 灯前目力虽非昔，犹课蝇头二万言。 android 笔记 compose ViewModel
通过ViewModel组件用于保存视图中需要的数据。ViewModel主要目的是将与用户界面相关的数据模型和应用程序的逻辑与负责实际显示和管理用户界面以及与操作系统交互的代码分离开来，为UI界面管理数据。常见的管理方式主要有：LiveData和StateFlow两种形式来实现的。在下列将结合一个简单字符串加密和解密的应用来说明ViewModel管理数据的过程。一、ViewModel的配置在项目模块
Android笔记（十二）：结合Compose实现Handler机制处理多线程的通信灯前目力虽非昔，犹课蝇头二万言。 android 笔记 compose Handler机制
在Android应用中常常结合多线程处理多个任务。不可避免，多个线程之间需要数据通信。Hanlder消息处理机制是异步处理的方式之一。通过Handler机制可以实现在不同的线程之间的通信。一、主线程和工作线程1.主线程一个Android的移动应用启动时会单独启动一个进程。这个进程中可以存在多个线程。但是这么多线程中有且仅有一个主线程，即UI线程。Android应用程序运行时创建UI主线程，它主要是
Android笔记--WebSocket ljt2724960661 Android基础 android 笔记 websocket 网络协议
这一节了解一下WebSocket的用法，WebSocket是一种基于TCP的全双工通信协议，通过它可以在客户端和服务器之间建立一个持久的连接，实现实时的双向数据传输。它的主要功能特点是允许服务器主动向客户端推送信息，同时也允许客户端主动向服务器发送信息。用法如下:app下的gradle:implementation"org.java-websocket:Java-WebSocket:1.5.3"服
Android笔记--App缓存 ljt2724960661 android 笔记缓存
获取应用缓存方式如下：importandroid.app.usage.UsageStats;importandroid.app.usage.UsageStatsManager;importandroid.content.Context;importandroid.content.pm.PackageManager;importandroid.os.Process;importandroid.os.
查漏补缺！阿里内部Android笔记火爆IT圈，已拿offer入职左夜天程序员 android
一些感悟穷人的一次失败，为了还债可能一辈子都翻不了身，为还债一辈子送外卖。你将不再会有精力去思考和投机。穷人的失败可能断送了他所有暴富的机遇和时间，让不确定的人生瞬间确定下来，让充满无限可能的人生可能性逐渐缩小。这是赤裸裸的现实。只有当你有足够多的资本时，允许你失误的次数才会逐渐增加。拥有足够多的资本，哪怕尝试个三番五次失败了，也不会伤你元气。所以从这个角度讲，人的机遇是随着财富的增加而增加的。这
Android笔记（五）：结合Compose组件利用ActivityResultLauncher解决多活动跳转返回数据灯前目力虽非昔，犹课蝇头二万言。 android 笔记 android compose
在本人博客中Android活动返回不在再支持startActivityForResult()后的处理方法已经记录采用ActivityResultLauncher来处理多活动的返回并传回数据的方式。但是采用的是布局xml+viewBinding技术。目前，谷歌官方推荐使用JetPackCompose组件来定义界面。在本文中，将介绍在JetPackCompose定义的界面中ActivityResult
Android笔记（七）Android JetPack Compose组件搭建Scaffold脚手架灯前目力虽非昔，犹课蝇头二万言。 android jetpack android Scaffold android compose
在去年2022年曾发布一篇关于脚手架的文章：“AndroidJetPackCompose组件中Scaffold的应用”。但是Android的版本从12变更到13及以上版本，导致一些细节的实现存在不同。在本文中，将从头开始介绍整个脚手架的搭建过程。一、新建项目模块在AndroidStudio（版本是Graffie)中新建模块，选择“EmptyActivity",如图1所示。图1二、定义脚手架Scaf
Android笔记（九）：Compose组件的状态（一）灯前目力虽非昔，犹课蝇头二万言。 android 笔记 Compose 界面状态状态提升状态的保存和恢复
在使用Compose定义UI界面时，可以发现界面的变换往往与Compose组件内部的状态相关，当状态值发生变化时，Compose构成的可组合的界面也会刷新发生相应的变化。将在本笔记中将对可组合项的状态的定义、状态提升、状态丢失和状态的保存进行简单介绍。。一、什么是可组合项的状态Compose采用了单向数据流设计思想。定义界面的可组合函数本身没有任何返回值，也没有像类一样封装内部的私有状态。因此通过
Android笔记（八）：基于CameraX库结合Compose和传统视图组件PreviewView实现照相机画面预览和照相功能灯前目力虽非昔，犹课蝇头二万言。 android 笔记 CameraX Compose PreviewView
CameraX是JetPack库之一，通过CameraX可以向应用增加相机的功能。在下列内容中，将介绍一个结合CameraX实现一个简单的拍照应用。本应用必须采用AndroidSDK34。并通过该简单示例，了解传统View层次组件的UI组件如何与Compose组件结合实现移动应用界面的定制。首先，新建一个项目，选择EmptyActivity。一、增加依赖使用CameraX在新建项目的模块build
Android重要知识文档记录麦田里的守望者-Jiang Androidpn android 技术文档
1.Android笔记：常用的开发资源和技术博客2.面向贡献者的代码样式指南：谷歌官方代码规范以下代码样式都是应严格遵守的规则（而非指南或建议）。如果所贡献的Android代码没有遵守以下规则，我们通常不会接受此类代码。我们知道，并非所有的现有代码都遵守了这些规则，但我们希望所有新代码都能遵守这些规则。3.支持多种屏幕Android可在各种具有不同屏幕尺寸和密度的设备上运行。对于应用，Androi
java类加载顺序 3213213333332132 java
package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
Hibernate与mybitas的比较 BlueSkator sql Hibernate 框架 ibatis orm
第一章 Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
php多维数组排序以及实际工作中的应用 dcj3sjt126com PHP usort uasort
自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
DOM改变字体大小周华华前端
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
c3p0的配置 g21121 c3p0
c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。以在spring中配置dataSource为例：  <bean name="prope
Java获取工程路径的几种方法 510888780 java
第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
在类Unix系统下实现SSH免密码登录服务器 Harry642 免密 ssh
1.客户机 (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址 (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址 (3)执行cat
Java新手入门的30个基本概念一 aijuans java java 入门新手
在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
Memcached for windows 简单介绍 antlove java Web windows cache memcached
1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
数据库对象的视图和索引百合不是茶索引 oeacle数据库视图
视图视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图为什么oracle需要视图; &
Mockito(一) --入门篇 bijian1013 持续集成 mockito 单元测试
Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。 &nb
精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle 数据库 plsql
/* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
【Log4j一】Log4j总体介绍 bit1129 log4j
Log4j组件：Logger、Appender、Layout Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能：日志的输出目标日志的输出格式日志的输出级别(是否抑制日志的输出) logger继承特性 A logger is said to be an ancestor of anothe
Java IO笔记白糖_ java
public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
Docker 监控 ronin47 docker监控
目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容监控宿主机本身监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。额外的，因为是docker的
java-顺时针打印图形 bylijinnan java
一个画图程序要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下：在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。 # ${HOME} will be replaced by user home directory accordin
[并行计算]论宇宙的可计算性 comsci 并行计算
现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识...... 那么,这种概念让我们推论出一个结论 &nb
用OpenGL实现无限循环的coverflow dai_lm android coverflow
网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
JAVA数据计算的几个解决方案1 datamachine java Hibernate 计算
老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线------------------------------------- 数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J &nbs
简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
怎么创建一个简单的(非 RBAC)用户授权系统通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。数据库首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限扩展 CWebUser 类在配置文件(一般为 protecte
未选之路 dcj3sjt126com 诗
作者:罗伯特*费罗斯特黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处. 但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹. 那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
Java处理15位身份证变18位蕃薯耀 18位身份证变15位 15位身份证变18位身份证转换
15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。 Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml <!-- 激活自动代理功能参看：
Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScript html android 脚本
在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序要在webview中,调用addJavascriptInterface(OBJ,int
8个最佳Web开发资源推荐 lampcy 编程 Web 程序员
Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。这里列出10个最佳Web开发资源，它们都是受
架构师之面试------jdk的hashMap实现 nannan408 HashMap
1.前言。如题。 2.详述。 (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
html禁止清除input文本输入缓存 Rainbow702 html 缓存 input 输入框 change
多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。如果不想让浏览器缓存input的值，有2种方法：方法一：在不想使用缓存的input中添加 autocomplete="off"; <input type="text" autocomplete="off" n
POJO和JavaBean的区别和联系 tjmljw POJO java beans
POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
java中单例的五种写法 liuxiaoling java 单例
/** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri