简单实用的OkHttp3入门精简教程-低调大师

简单实用的OkHttp3入门精简教程

2017-08-14 576

自定义View系列教程00–推翻自己和过往，重学自定义View
自定义View系列教程01–常用工具介绍
 自定义View系列教程02–onMeasure源码详尽分析
 自定义View系列教程03–onLayout源码详尽分析
 自定义View系列教程04–Draw源码分析及其实践
 自定义View系列教程05–示例分析
 自定义View系列教程06–详解View的Touch事件处理
 自定义View系列教程07–详解ViewGroup分发Touch事件
 自定义View系列教程08–滑动冲突的产生及其处理

探索Android软键盘的疑难杂症
 深入探讨Android异步精髓Handler
详解Android主流框架不可或缺的基石
 站在源码的肩膀上全解Scroller工作机制

Android多分辨率适配框架（1）— 核心基础
 Android多分辨率适配框架（2）— 原理剖析
 Android多分辨率适配框架（3）— 使用指南

本文将用最简的代码和语句介绍OkHttp3的常用基本操作。

准备工作

导入OkHttp3

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

添加权限


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

请注意：假若你看到此处不明白为什么需要做这些准备工作，那么请点击浏览器右上角的八叉 ( X )

Post,Get,上传,下载

package com.cn.okhttp01;

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Environment;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

/**
 * 原创作者：谷哥的小弟
 * 博客地址：http://blog.csdn.net/lfdfhl
 */
public class MainActivity extends AppCompatActivity {
    public final static String TAG="reborn";
    private static final int REQUEST_CODE = 9527;
    private static String[] PERMISSIONS = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE };
    private Context mContext;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
    }
    private void init(){
        mContext=this;
        verifyStoragePermissions(this);
    }

    private void testOkHttp(){
        testUpload();
    }

    public void verifyStoragePermissions(Activity activity) {
        int permission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE);
        if (permission != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(activity, PERMISSIONS, REQUEST_CODE);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        switch (requestCode) {
            case REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    testOkHttp();
                } else {
                    Toast.makeText(mContext, "您未授权存储权限", Toast.LENGTH_LONG).show();
                }
                break;
            default:
        }
    }


    //Get同步请求
    public void testGet1(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String url="http://blog.csdn.net/lfdfhl";
                    OkHttpClient okHttpClient=new OkHttpClient();
                    Request.Builder requestBuilder=new Request.Builder();
                    requestBuilder.url(url);
                    Request request=requestBuilder.build();
                    Call call=okHttpClient.newCall(request);
                    Response response=call.execute();
                    String result=response.body().string();
                    response.body().close();
                    Log.i(TAG,"测试Get同步请求 "+result);
                }catch (Exception e){

                }
            }
        }).start();
    }

    //Get异步请求
    public void testGet2(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String url="http://blog.csdn.net/lfdfhl";
                    OkHttpClient okHttpClient=new OkHttpClient();
                    Request.Builder requestBuilder=new Request.Builder();
                    requestBuilder.url(url);
                    Request request=requestBuilder.build();
                    Call call=okHttpClient.newCall(request);
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {

                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            int code=response.code();
                            String result=response.body().string();
                            response.body().close();
                            Log.i(TAG,"code="+code);
                            Log.i(TAG,"测试Get异步请求 "+result);
                        }
                    });
                }catch (Exception e){

                }
            }
        }).start();
    }


    //POST同步请求
    public void testPost1(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String url="http://106.14.136.52:8080/user/login";
                    OkHttpClient okHttpClient=new OkHttpClient();
                    Request.Builder requestBuilder=new Request.Builder();
                    FormBody.Builder formBodyBuilder=new FormBody.Builder();
                    formBodyBuilder.add("username","andy");
                    formBodyBuilder.add("password","123456");
                    RequestBody requestBody=formBodyBuilder.build();
                    requestBuilder.url(url);
                    requestBuilder.post(requestBody);
                    requestBuilder.addHeader("apikey","81bf9da930c7f9825a3c3383f1d8d766");
                    Request request=requestBuilder.build();
                    Response response=okHttpClient.newCall(request).execute();
                    int code=response.code();
                    String result=response.body().string();
                    response.body().close();
                    Log.i(TAG,"code="+code);
                    Log.i(TAG,"测试Post同步请求 "+result);
                }catch (Exception e){

                }
            }
        }).start();
    }


    //POST异步请求
    public void testPost2(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String url="http://106.14.136.52:8080/user/login";
                    OkHttpClient okHttpClient=new OkHttpClient();
                    Request.Builder requestBuilder=new Request.Builder();
                    FormBody.Builder formBodyBuilder=new FormBody.Builder();
                    formBodyBuilder.add("username","andy");
                    formBodyBuilder.add("password","123456");
                    RequestBody requestBody=formBodyBuilder.build();
                    requestBuilder.url(url);
                    requestBuilder.post(requestBody);
                    Request request=requestBuilder.build();
                    Call call=okHttpClient.newCall(request);
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {

                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            int code=response.code();
                            String result=response.body().string();
                            response.body().close();
                            Log.i(TAG,"code="+code);
                            Log.i(TAG,"测试Post异步请求 "+result);
                        }
                    });

                }catch (Exception e){

                }
            }
        }).start();
    }

    //下载
    public void testDownload(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String url="http://img.blog.csdn.net/20161023140032428";
                    final File downloadFile=new File(getExternalCacheDir().toString()+File.separator+"test.jpg");
                    OkHttpClient okHttpClient=new OkHttpClient();
                    Request.Builder requestBuilder=new Request.Builder();
                    requestBuilder.url(url);
                    Request request=requestBuilder.build();
                    Call call=okHttpClient.newCall(request);
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {

                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            if(response.isSuccessful()){
                                InputStream inputStream=response.body().byteStream();
                                FileOutputStream fileOutputStream=new FileOutputStream(downloadFile);
                                int len=0;
                                byte b []=new byte[1024*2];
                                while ((len=inputStream.read(b))!=-1){
                                    fileOutputStream.write(b,0,len);
                                }
                                fileOutputStream.close();
                                inputStream.close();
                            }
                            response.body().close();
                            Bitmap bitmap = BitmapFactory.decodeFile(downloadFile.getAbsolutePath());
                            Log.i(TAG,"width="+bitmap.getWidth());
                            Log.i(TAG,"height="+bitmap.getHeight());
                        }
                    });

                }catch (Exception e){

                }
            }
        }).start();
    }

    //上传
    public void testUpload(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    String url ="http:192.168.0.103:8081/SpringMVC07/testUpload/uploadFile.do";
                    OkHttpClient okHttpClient=new OkHttpClient();
                    MultipartBody.Builder multipartBodyBuilder=new MultipartBody.Builder();
                    //添加文件
                    File file=new File(Environment.getExternalStorageDirectory().getAbsolutePath()+File.separator+"test.jpg");
                    String fileName=file.getName();
                    MediaType mediaType=MediaType.parse("image/*");
                    RequestBody requestBody=RequestBody.create(mediaType,file);
                    multipartBodyBuilder.setType(MultipartBody.FORM);
                    multipartBodyBuilder.addFormDataPart("photo",fileName,requestBody);
                    //添加参数
                    multipartBodyBuilder.addFormDataPart("name","zxx");
                    multipartBodyBuilder.addFormDataPart("number","9527");
                    multipartBodyBuilder.addFormDataPart("country","China");
                    MultipartBody multipartBody=multipartBodyBuilder.build();
                    Request.Builder requestBuilder=new Request.Builder();
                    requestBuilder.url(url);
                    requestBuilder.post(multipartBody);
                    Request request=requestBuilder.build();
                    Call call=okHttpClient.newCall(request);
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {
                            Log.i(TAG,"onFailure");
                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            Log.i(TAG,"onResponse");
                        }
                    });

                }catch (Exception e){

                }
            }
        }).start();
    }

}

请注意：测试时，请将url替换成您自己的可用地址

OkHttp拦截器

package com.cn.okhttp02;

import android.content.Context;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import java.io.IOException;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

/**
 * 原创作者：谷哥的小弟
 * 博客地址：http://blog.csdn.net/lfdfhl
 */
public class MainActivity extends AppCompatActivity {
    public final static String TAG="reborn";
    private Context mContext;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
        testApplicationInterceptors();
        testNetworkInterceptors();
    }
    private void init(){
        mContext=this;
    }


    //测试Application Interceptors
    public void testApplicationInterceptors(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    Log.i(TAG,"----> run");
                    String url="http://blog.csdn.net/lfdfhl";
                    OkHttpClient.Builder okHttpClientBuilder= new OkHttpClient.Builder();
                    //添加应用拦截器
                    okHttpClientBuilder.addInterceptor(new LoggingInterceptor());
                    OkHttpClient okHttpClient=okHttpClientBuilder.build();
                    Request.Builder requestBuilder=new Request.Builder();
                    requestBuilder.url(url);
                    requestBuilder.addHeader("os","Android");
                    requestBuilder.addHeader("country","China");
                    Request request=requestBuilder.build();
                    Call call=okHttpClient.newCall(request);
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {
                            Log.i(TAG,"----> onFailure");
                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            Log.i(TAG,"----> onResponse");
                            int code=response.code();
                            String result=response.body().string();
                            response.body().close();
                            Log.i(TAG,"测试Application Interceptors "+result);
                        }
                    });
                }catch (Exception e){

                }
            }
        }).start();
    }


    //测试Network Interceptors
    public void testNetworkInterceptors(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    Log.i(TAG,"----> run");
                    String url="http:www.github.com";
                    OkHttpClient.Builder okHttpClientBuilder= new OkHttpClient.Builder();
                    //添加网络拦截器
                    okHttpClientBuilder.addNetworkInterceptor(new LoggingInterceptor());
                    OkHttpClient okHttpClient=okHttpClientBuilder.build();
                    Request.Builder requestBuilder=new Request.Builder();
                    requestBuilder.url(url);
                    requestBuilder.addHeader("os","Android");
                    requestBuilder.addHeader("country","China");
                    Request request=requestBuilder.build();
                    Call call=okHttpClient.newCall(request);
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {
                            Log.i(TAG,"----> onFailure");
                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            Log.i(TAG,"----> onResponse");
                            int code=response.code();
                            String result=response.body().string();
                            response.body().close();
                            Log.i(TAG,"测试Network Interceptors "+result);
                        }
                    });
                }catch (Exception e){

                }
            }
        }).start();
    }


    class LoggingInterceptor implements Interceptor {
        @Override
        public Response intercept(Interceptor.Chain chain) throws IOException {
            Log.i(TAG,"----> intercept");
            Request request = chain.request();
            long t1 = System.nanoTime();
            Log.i(TAG, "intercept: " + String.format("Sending request %s on %s%n%s",request.url(), chain.connection(), request.headers()));
            Response response = chain.proceed(request);
            long t2 = System.nanoTime();
            Log.i(TAG, "intercept: " + String.format("Received response for %s in %.1fms%n%s",response.request().url(), (t2 - t1) / 1e6d, response.headers()));
            return response;
        }
    }

}

什么是拦截器呢？

拦截器能对Call进行监测、改写、重试连接；它能够对请求和响应进行二次加工。通俗地说：拦截器是请求和回复之间的一道门——发出请求时数据需要从这道门出去；接收响应时数据需要从这道门进来。当然，当数据(不论进出)经过这道门时，该门可对数据进行某些操作。

OkHttp3常用的拦截器分为：

Application Interceptors 应用拦截器
Network Interceptors 网络拦截器

这两个拦截器有什么区别呢？

Application interceptors 应用拦截器

Don’t need to worry about intermediate responses like redirects and retries.
不关心中间过程的响应，如重定向和重试
Are always invoked once, even if the HTTP response is served from the cache.
总是只调用一次，即使HTTP响应是从缓存中获取
Observe the application’s original intent. Unconcerned with OkHttp-injected headers like If-None-Match.
关注应用程序的初衷. 不关心OkHttp注入的头信息如: If-None-Match.
Permitted to short-circuit and not call Chain.proceed().
允许短路且不调用Chain.proceed()
Permitted to retry and make multiple calls to Chain.proceed().
允许重试，多次调用 Chain.proceed()

Network Interceptors 网络拦截器

Able to operate on intermediate responses like redirects and retries.
能够操作中间过程的响应，如重定向和重试.
Not invoked for cached responses that short-circuit the network.
当网络短路返回缓存响应时不被调用
Observe the data just as it will be transmitted over the network.
只观察在网络上传输的数据.
Access to the Connection that carries the request.
携带请求访问连接

拦截器使用场景

为request统一添加header
检查response判定用户登录信息是否失效，并用Dialog提示用户登录
重写响应头和改变响应体。但不是很推荐这么做，因为可能违反web服务器的期望。

微信关注我们

原文链接：https://yq.aliyun.com/articles/267377

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

微软开始测试Windows 10邮件应用程序上的聚焦收件箱

微软已经开始测试Windows 10 Mail应用程序上著名的聚焦收件箱(Focused Inbox)功能。此功能已在其他平台(即iOS和Android)上可用，但是，此功能在Windows 10上推出似乎并不太远，因为某些用户已报告有权访问该功能。聚焦收件箱显示来自电子邮件帐户当中的重要邮件，例如非垃圾邮件，常用联系人发来的电子邮件等等，以便可以从一个位置访问重要邮件，而不必进入众多不同的文件夹，以节省时间，特别是在工作场所。该功能有两个选项，聚焦和其他，允许用户快速查看最重要的电子邮件，并在随后查看其他电子邮件。由于该功能正在测试，因此并非每个Windows 10都将有权访问它此项功能，随着时间推移，可能有更多的用户将能够使用聚焦收件箱。本文作者：佚名来源：51CTO

2017-08-15

543

2015年是新开源项目风生水起的一年！大到从企业解决方案、小到家庭应用都酝酿着各式各样的开源产品！很多开源项目在这一年都是迅猛崛起的！尽管流星般的闪现并不能意味着长久，但是我们认为这 10 个项目有足够的气势在新的一年挥洒霓虹！你可以把下面一些项目称作 2016 最可能成功的产品。幸运的是，通过 GitHub，我们可以很方便的衡量出开发者们的兴趣点！下面的这些列表，是我们根据过去一年当中用户加星标数量的 Github 代码仓库来恒定的！这些项目，令我们感到惊奇！如果你也有如我们一般感同身受，为什么不点进去看一看，clone 你喜欢的代码，尝试着玩一玩！如果你也想为这些开源做贡献，为什么不 fork 一番?让这些项目在新年里发扬光大? 1.React Native React Native 是一个 JavaScript 的框架，可以让你用同样的机制去构建 Android 和 iOS 应用，其原理与创建 web 应用用到的 React 是一样的。Facebook 的 React 是 2013 年推出的，而基于 React 的 native 的框架是今年早些时候发布的时候就非常让人期待。...

2017-08-15

623

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。