SmartDengg/Android网络最佳实践

   URL url = new URL("http://www.android.com/");
   HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
   try {
     InputStream in = new BufferedInputStream(urlConnection.getInputStream());
     readStream(in);
   } finally {
     urlConnection.disconnect();
   }

   HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
   try {
     urlConnection.setDoOutput(true);
     //"0"代表使用默认的分块长度“1024” 
     urlConnection.setChunkedStreamingMode(0);

     OutputStream out = new BufferedOutputStream(urlConnection.getOutputStream());
     writeStream(out);

     InputStream in = new BufferedInputStream(urlConnection.getInputStream());
     readStream(in);
   } finally {
     urlConnection.disconnect();
   }

   urlConnection.setRequestProperty("Accept-Encoding", "identity");

   Authenticator.setDefault(new Authenticator() {
     protected PasswordAuthentication getPasswordAuthentication() {
       return new PasswordAuthentication(username, password.toCharArray());
     }
   });

   private void disableConnectionReuseIfNecessary() {
   // Work around pre-Froyo bugs in HTTP connection reuse.
   if (Integer.parseInt(Build.VERSION.SDK) < Build.VERSION_CODES.FROYO) {
     System.setProperty("http.keepAlive", "false");
   }
 }

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

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

  private StringBuffer getParamString(Map<String, String> params) {
    StringBuffer result = new StringBuffer();
    Iterator<Map.Entry<String, String>> iterator = params.entrySet().iterator();
    while (iterator.hasNext()) {
      Map.Entry<String, String> param = iterator.next();
      String key = param.getKey();
      String value = param.getValue();
      result.append(key).append('=').append(value);
      if (iterator.hasNext()) {
        result.append('&');
      }
    }
    return result;
  }

    //创建HttpClient
    private HttpClient createHttpClient() {
        HttpParams defaultHttpParams = new BasicHttpParams();
        //设置连接超时
        HttpConnectionParams.setConnectionTimeout(defaultHttpParams, 15000);
        //设置请求超时
        HttpConnectionParams.setSoTimeout(defaultHttpParams, 15000);
        HttpConnectionParams.setTcpNoDelay(defaultHttpParams, true);
        HttpProtocolParams.setVersion(defaultHttpParams, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(defaultHttpParams, HTTP.UTF_8);
        //持续握手
        HttpProtocolParams.setUseExpectContinue(defaultHttpParams, true);
        HttpClient httpClient = new DefaultHttpClient(defaultHttpParams);
        return httpClient;
    }

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

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

private String converStreamToString(InputStream is) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuffer sb = new StringBuffer();
        String line = null;
        while ((line = reader.readLine()) != null) {
            sb.append(line + "\n");
        }
        String respose = sb.toString();
        return respose;
    }

AsyncHttpClient client = new AsyncHttpClient();
client.get("https://www.google.com", new AsyncHttpResponseHandler() {

    @Override
    public void onStart() {
        // called before request is started
    }

    @Override
    public void onSuccess(int statusCode, Header[] headers, byte[] response) {
        // called when response HTTP status is "200 OK"
    }

    @Override
    public void onFailure(int statusCode, Header[] headers, byte[] errorResponse, Throwable e) {
        // called when response HTTP status is "4XX" (eg. 401, 403, 404)
    }

    @Override
    public void onRetry(int retryNo) {
        // called when request is retried
    }
});

    AsyncHttpClient client = new AsyncHttpClient();
    RequestParams params = new RequestParams();
    params.put("key", "value");
    params.put("more", "data");
    RequestHandle requestHandle =
        client.get("http://www.google.com", params, new TextHttpResponseHandler() {
          @Override public void onSuccess(int statusCode, Header[] headers, String res) {
            // called when response HTTP status is "200 OK"
          }

          @Override
          public void onFailure(int statusCode, Header[] headers, String res, Throwable t) {
            // called when response HTTP status is "4XX" (eg. 401, 403, 404)
          }
        });

    requestHandle.cancel(true);

import org.json.*;
import com.loopj.android.http.*;

class TwitterRestClientUsage {
    public void getPublicTimeline() throws JSONException {
        TwitterRestClient.get("statuses/public_timeline.json", null, new JsonHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
                // If the response is JSONObject instead of expected JSONArray
            }

            @Override
            public void onSuccess(int statusCode, Header[] headers, JSONArray timeline) {
                // Pull out the first event on the public timeline
                JSONObject firstEvent = timeline.get(0);
                String tweetText = firstEvent.getString("text");

                // Do something with the response
                System.out.println(tweetText);
            }
        });
    }
}

public class TwitterRestClient {
  private static final String BASE_URL = "https://api.twitter.com/1/";

  private static AsyncHttpClient client = new AsyncHttpClient();

  public static void get(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {
      client.get(getAbsoluteUrl(url), params, responseHandler);
  }

  public static void post(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {
      client.post(getAbsoluteUrl(url), params, responseHandler);
  }

  private static String getAbsoluteUrl(String relativeUrl) {
      return BASE_URL + relativeUrl;
  }
}

import org.apache.http.Header;

import cz.msebera.android.httpclient.Header;

FinalHttp fh = new FinalHttp();
fh.get("http://www.yangfuhai.com", new AjaxCallBack(){

    @Override
    public void onLoading(long count, long current) { //每1秒钟自动被回调一次
            textView.setText(current+"/"+count);
    }

    @Override
    public void onSuccess(String t) {
            textView.setText(t==null?"null":t);
    }

    @Override
    public void onStart() {
        //开始http请求的时候回调
    }

    @Override
    public void onFailure(Throwable t, String strMsg) {
        //加载失败的时候回调
    }
});

  AjaxParams params = new AjaxParams();
  params.put("username", "michael yang");
  params.put("password", "123456");
  params.put("email", "test@tsz.net");
  params.put("profile_picture", new File("/mnt/sdcard/pic.jpg")); // 上传文件
  params.put("profile_picture2", inputStream); // 上传数据流
  params.put("profile_picture3", new ByteArrayInputStream(bytes)); // 提交字节流

  FinalHttp fh = new FinalHttp();
  fh.post("http://www.yangfuhai.com", params, new AjaxCallBack(){
        @Override
        public void onLoading(long count, long current) {
                textView.setText(current+"/"+count);
        }

        @Override
        public void onSuccess(String t) {
            textView.setText(t==null?"null":t);
        }
  });

FinalHttp fh = new FinalHttp();  
    //调用download方法开始下载
    HttpHandler handler = fh.download("http://www.xxx.com/下载路径/xxx.apk", //这里是下载的路径
    true,//true:断点续传 false:不断点续传（全新下载）
    "/mnt/sdcard/testapk.apk", //这是保存到本地的路径
    new AjaxCallBack() {  
                @Override  
                public void onLoading(long count, long current) {  
                     textView.setText("下载进度："+current+"/"+count);  
                }  

                @Override  
                public void onSuccess(File t) {  
                    textView.setText(t==null?"null":t.getAbsoluteFile().toString());  
                }  

            });  


   //调用stop()方法停止下载
   handler.stop();

HttpUtils http = new HttpUtils();
http.send(HttpRequest.HttpMethod.GET,
    "http://www.lidroid.com",
    new RequestCallBack<String>(){
        @Override
        public void onLoading(long total, long current, boolean isUploading) {
            testTextView.setText(current + "/" + total);
        }

        @Override
        public void onSuccess(ResponseInfo<String> responseInfo) {
            textView.setText(responseInfo.result);
        }

        @Override
        public void onStart() {
        }

        @Override
        public void onFailure(HttpException error, String msg) {
        }
});

RequestParams params = new RequestParams();
params.addHeader("name", "value");
params.addQueryStringParameter("name", "value");

// 只包含字符串参数时默认使用BodyParamsEntity，
// 类似于UrlEncodedFormEntity（"application/x-www-form-urlencoded"）。
params.addBodyParameter("name", "value");

// 加入文件参数后默认使用MultipartEntity（"multipart/form-data"），
// 如需"multipart/related"，xUtils中提供的MultipartEntity支持设置subType为"related"。
// 使用params.setBodyEntity(httpEntity)可设置更多类型的HttpEntity（如：
// MultipartEntity,BodyParamsEntity,FileUploadEntity,InputStreamUploadEntity,StringEntity）。
// 例如发送json参数：params.setBodyEntity(new StringEntity(jsonStr,charset));
params.addBodyParameter("file", new File("path"));
...

HttpUtils http = new HttpUtils();
http.send(HttpRequest.HttpMethod.POST,
    "uploadUrl....",
    params,
    new RequestCallBack<String>() {

        @Override
        public void onStart() {
            testTextView.setText("conn...");
        }

        @Override
        public void onLoading(long total, long current, boolean isUploading) {
            if (isUploading) {
                testTextView.setText("upload: " + current + "/" + total);
            } else {
                testTextView.setText("reply: " + current + "/" + total);
            }
        }

        @Override
        public void onSuccess(ResponseInfo<String> responseInfo) {
            testTextView.setText("reply: " + responseInfo.result);
        }

        @Override
        public void onFailure(HttpException error, String msg) {
            testTextView.setText(error.getExceptionCode() + ":" + msg);
        }
});

HttpUtils http = new HttpUtils();
HttpHandler handler = http.download("http://apache.dataguru.cn/httpcomponents/httpclient/source/httpcomponents-client-4.2.5-src.zip",
    "/sdcard/httpcomponents-client-4.2.5-src.zip",
    true, // 如果目标文件存在，接着未完成的部分继续下载。服务器不支持RANGE时将从新下载。
    true, // 如果从请求返回信息中获取到文件名，下载完成后自动重命名。
    new RequestCallBack<File>() {

        @Override
        public void onStart() {
            testTextView.setText("conn...");
        }

        @Override
        public void onLoading(long total, long current, boolean isUploading) {
            testTextView.setText(current + "/" + total);
        }

        @Override
        public void onSuccess(ResponseInfo<File> responseInfo) {
            testTextView.setText("downloaded:" + responseInfo.result.getPath());
        }


        @Override
        public void onFailure(HttpException error, String msg) {
            testTextView.setText(msg);
        }
});

...
//调用cancel()方法停止下载
handler.cancel();

    // Instantiate the RequestQueue. 
    RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
    String url = "http://www.google.com";

    // Request a string response from the provided URL. 
    StringRequest stringRequest = new StringRequest(url, new Response.Listener<String>() {
      @Override public void onResponse(String response) {
        //update ui

      }
    }, new Response.ErrorListener() {
      @Override public void onErrorResponse(VolleyError error) {
        //handle error

      }
    });
    // Add the request to the RequestQueue.
    queue.add(stringRequest);

     // Instantiate the RequestQueue. 
    RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
    String url = "http://www.google.com";

     // Request a string response from the provided URL. 
    StringRequest stringRequest =
        new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
          @Override public void onResponse(String response) {

          }
        }, new Response.ErrorListener() {
          @Override public void onErrorResponse(VolleyError error) {

          }
        }) {
          @Override protected Map<String, String> getParams() throws AuthFailureError {
            Map<String, String> params = new HashMap<String, String>();
            params.put("user", "deng");
            params.put("pass", "123"); 
            return params;
          }
        };

    // Add the request to the RequestQueue. 
    queue.add(stringRequest);

//为请求标记TAG
stringRequest.setTag(TAG); 
//将设置TAG的请求添加到请求队列中
mRequestQueue.add(stringRequest); 

//通过请求队列取消相同TAG的请求
mRequestQueue.cancelAll(TAG);

// Instantiate the RequestQueue. 
RequestQueue queue = Volley.newRequestQueue(getApplicationContext());
String url = "http://my-json-feed";

JsonObjectRequest jsObjRequest = new JsonObjectRequest
        (Request.Method.GET, url, null, new Response.Listener<JSONObject>() {
    @Override
    public void onResponse(JSONObject response) {

    }
}, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {

    }
});

// Add the request to the RequestQueue. 
queue.add(request);

Cache cache = queue.getCache();
Entry entry = cache.get(url);
if(entry != null){
    try {
        String data = new String(entry.data, "UTF-8");
        // handle data, like converting it to xml, json, bitmap etc.,
    } catch (UnsupportedEncodingException e) {      
        e.printStackTrace();
        }
    }
}else{
    // Cached response doesn't exists. Make network call here
}

stringRequest.setShouldCache(false);

queue.getCache().remove(url);

queue.getCache().clear();

queue.getCache().invalidate(url,true);

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  Response response = client.newCall(request).execute();
  return response.body().string();
}

public static final MediaType JSON
    = MediaType.parse("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(JSON, json);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  Response response = client.newCall(request).execute();
  return response.body().string();
}

public final class BridgeInterceptor implements Interceptor {

  @Override public Response intercept(Chain chain) throws IOException {
    Request userRequest = chain.request();
    Request.Builder requestBuilder = userRequest.newBuilder();

    ...

    // 1.判断请求头信息"Accept-Encoding"是否存在
    // 2.如果是okhttp添加的"Accept-Encoding: gzip",那么也将负责解压缩
    // 3.如果原始请求头中存在"Accept-Encoding: gzip",那么okhttp不负责对响应进行解压缩,需要手动解压缩
    boolean transparentGzip = false;
    if (userRequest.header("Accept-Encoding") == null) {
      transparentGzip = true;
      requestBuilder.header("Accept-Encoding", "gzip");
    }

    ...

    // 4.发生网络传输,并获取响应
    Response networkResponse = chain.proceed(requestBuilder.build());

    Response.Builder responseBuilder = networkResponse.newBuilder().request(userRequest);

    // 5.判断响应头是否包含"Content-Encoding: gzip"字段,并且由okhttp负责解压缩
    if (transparentGzip
        && "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
        && HttpHeaders.hasBody(networkResponse)) {

      // 6.对响应进行解压缩
      GzipSource responseBody = new GzipSource(networkResponse.body().source());

      Headers strippedHeaders = networkResponse.headers()
          .newBuilder()
          .removeAll("Content-Encoding") // 7.移除"Content-Encoding"响应头字段
          .removeAll("Content-Length")   // 8.移除"Content-Length"响应头字段
          .build();
      responseBuilder.headers(strippedHeaders);
      responseBuilder.body(new RealResponseBody(strippedHeaders, Okio.buffer(responseBody)));
    }

    return responseBuilder.build();
  }
}

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

GitHubService service = retrofit.create(GitHubService.class);

Call<List<Repo>> repos = service.listRepos("octocat");

List<Repo> repositories = repos.execute().body();

repos.enqueue(new Callback<List<Repo>>() {
      @Override public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {

      }

      @Override public void onFailure(Call<List<Repo>> call, Throwable t) {

      }
    });

@GET("/list")
Call<ResponseBody> list(@Query("page") int page);

.list(1) ===> /list?page=1

@GET("/list")
Call<ResponseBody> list(@Query("category") String category);

.list(null) ===> /list

@GET("/list")
Call<ResponseBody> list(@Query("category") String... categories);

.list("bar", "baz") ===> /list?category=bar&category=baz

 @GET("/search")
 Call<ResponseBody> list(@Query(value="foo", encoded=true) String foo);

.list() ===> .list("foo+bar")) yields /search?foo=foo+bar

public class DownloadWebPageTask extends AsyncTask<String, Voice, String> {

   ...

  @Override protected String doInBackground(String... urls) {

    String response = "";

    for (String url : urls) {

      try {
        InputStream inputStream = EffectiveHttpClient.retrieveService(url);
        BufferedReader buffered = new BufferedReader(new InputStreamReader(inputStream));

        String s = "";
        while ((s = buffered.readLine()) != null) {
          response += s;
        }
      } catch (IOException e) {
        //handle IOException

        //handle JSONException ?

        //handle inner Exception ?

        //handle Exception when nest call ?
      }
    }

    return response;
  }

  @Override protected void onPostExecute(String result) {
    mTextView.setText(result);
  }

  @Override protected void onCancelled(String result) {
    // handle cancel with result may be null
  }
}

private void retrieveMovies() {

    final Service service = ServiceGenerator.createService(Service.class);

    //1. 获取城市列表(网络操作)
    service.getCityList()
        .concatMap(new Func1<List<CityListResponse>, Observable<CityListResponse>>() {
          @Override
          public Observable<CityListResponse> call(List<CityListResponse> cityListResponses) {
            //2.依次取出"城市列表"集合中的元素
            return Observable.from(cityListResponses);
          }
        })
        .concatMap(new Func1<CityListResponse, Observable<List<MovieListResponse>>>() {
          @Override
          public Observable<List<MovieListResponse>> call(CityListResponse cityListResponse) {
            //3.根据每一个城市的id,获取该城市的电影列表(网络操作)
            return service.getMovies(cityListResponse.cityId);
          }
        })
        .concatMap(new Func1<List<MovieListResponse>, Observable<MovieListResponse>>() {
          @Override
          public Observable<MovieListResponse> call(List<MovieListResponse> movieListResponses) {
            //4.依次取出"电影列表"集合中的元素
            return Observable.from(movieListResponses);
          }
        })
        .concatMap(new Func1<MovieListResponse, Observable<MovieDetailResponse>>() {
          @Override
          public Observable<MovieDetailResponse> call(MovieListResponse movieListResponse) {
            //5.根据每一个电影的ID,获取该电影详情(网络操作)
            return service.getMovieDetail(movieListResponse.movieId);
          }
        })
        .subscribeOn(Schedulers.newThread())// 6.线程切换,上游的所有操作执行在工作线程
        .observeOn(AndroidSchedulers.mainThread())//7.线程切换,下游的所有将操作执行在UI线程
        .subscribe(new Subscriber<MovieDetailResponse>() {
          @Override public void onCompleted() {
          // finishCompletion
          }

          @Override public void onError(Throwable e) {
          //error handler
          }

          @Override public void onNext(MovieDetailResponse movieDetailResponse) {
            //8.根据电影ID所获取到的电影详情,该函数会被调用多次。
            textView.append(movieDetailResponse.movieName);
          }
        });
  }