Android | 网络技术基础梳理——WebView以及HTTP运用、XML以及JSON解析（demo+bug）-优快云博客

本文目录

1.WebView的用法

使用HTTP协议访问网络

2.1 使用HttpURLConnection
2.2 使用OkHttp

3.解析XML格式数据

3.1 Pull解析方式
3.2 SAX解析方式

4.解析JSON数据

4.1使用JSONObject
4.2 使用GSON
5.网络编程的最佳实践——HttpUtil封装（巧用回调机制、框架）

1.WebView的用法

使用WebView控件，
借其在自己的应用程序中嵌入一个浏览器，
以轻松展示各种网页；

新建一个WebViewTest项目，
修改activity_main.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <WebView
        android:id="@+id/web_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</LinearLayout>

接下来修改MainActivity.java：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        WebView webView = (WebView) findViewById(R.id.web_view);
        webView.getSettings().setJavaScriptEnabled(true);
        webView.setWebViewClient(new WebViewClient());
        webView.loadUrl("http://www.baidu.com");
    }
}

首先是findViewById实例化对象；
getSettings()用来设置浏览器属性；
setJavaScriptEnabled(true)让WebView支持JavaScript脚本；
调用WebView 的setWebViewClient()方法，
传入一个WebViewClient实例，
作用是：使当需要从一个网页跳转到另外一个网页时，
目标网页仍然在当前WebView中显示，而不是打开系统浏览器；
loadUrl()传入网址，显示网页内容；

接下来，还需在AndroidManifest.xml中添加访问网络的权限：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.webviewtest">
    
    <uses-permission android:name="android.permission.INTERNET"/>

...

</manifest>

至此，即可运行程序了，其效果如下：

当然还要注意一点，如果你的模拟器和SDK是Android 9.0（API级别28），那运行如上代码会出现下面这个问题：

原因是从Android 9.0（API级别28）开始，默认情况下禁用明文支持。
因此http的url均无法在webview中加载。

解决方法是在AndroidManifest.xml对应的地方加入一句代码即可：

android:usesCleartextTraffic="true"

解决之后便可以运行成功了：

当然，小伙伴们，生活往往没那么简单，
百度搜索引擎框下面有很多吸引我们眼球的文章对吧，

你会发现当你随便点击一篇文章，想要跳转过去的时候，会出现下方这种报错：

亦或者：

莫慌，其实都是一个道理，仔细看一下报错，我们可以发现url的前缀都被替换了：

这是因为其自定义了scheme，
类似的还有alipays://，weixin://等等。
而webView只能识别http://或https://开头的url，因此才会报此错。
处理方法，对于这种自定义scheme的url 单独处理即可。

修改代码如下：
我们刚刚写了这段代码对吧：
webView.setWebViewClient(new WebViewClient())
现在，
把传入的WebViewClient实例变成一个以WebViewClient为父类的匿名内部类，
并重写shouldOverrideUrlLoading()方法，
在里面对方才报错中的自定义scheme进行单独处理即可：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        final WebView webView = (WebView) findViewById(R.id.web_view);
        ...
        webView.setWebViewClient(new WebViewClient(){
            @Override
            public boolean shouldOverrideUrlLoading(WebView view, String url) {

                try{
                    if(url.startsWith("baiduboxapp://") || url.startsWith("baiduboxlite://" )){
                        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
                        startActivity(intent);
                        return true;
                    }
                }catch (Exception e){
                    return false;
                }
                webView.loadUrl(url);
                return true;
            }
        });
        webView.loadUrl("http://www.baidu.com");
    }
}

ok，这时候再运行程序，便可以成功打开各种推文了：

参考文章

2. 使用HTTP协议访问网络

HTTP基于android的工作原理简述
客户端向服务器发出一条HTTP请求，
服务器收到请求之后会返回一些数据给客户端，
然后客户端再对这些数据进行解析和处理就可以。
一个浏览器的基本工作原理也就是如上了。
上面使用的WebView控件，
其实也就是app向百度服务器发起一条HTTP请求，
接着服务器分析出我们想要访问的是百度的首页，
于是会把该网页的HTML代码进行返回，
然后WebView再调用手机浏览器的内核对返回的HTML代码进行解析，
最终将页面展示出来。
也即WebView封装了发送HTTP请求、接受服务响应、解析返回数据，以及最终页面的展示这几步工作。

下面暂时摆脱WebView，
手动发送HTTP请求，直观地理解一下HTTP协议的工作过程。

2.1 使用HttpURLConnection

首先，
获取HttpURLconnection的实例：

a. 以参数为目标的网络地址，new 出一个URL对象；
b. url对象调用openConnection()；
　返回的结果转型付给HttpURLConnection对象；

URL url = new URL("http://www.baidu.com");
HttpURLConnection connection = (HttpURLConnection)url.openConnection();

得到HttpURLConnection实例之后，设置HTTP请求所使用的方法；

常使用的方法主要有两个：GET和POST。
GET表示希望从服务器获取数据，
POST希望提交数据给服务器：

connection.setRequestMethod("GET");

接下来进行一些自由的定制，
如设置连接超时、读取超时的毫秒数、服务器希望得到的一些消息头等。
这些都是自己根据实际情况进行编写：

connection.setConnectTimeout(8000);
connection.setReadTimeout(8000);

之后再调用getInputStream()方法，
就可以获取到服务器返回的输入流了，
后续的对输入流进行读取即可：

InputStream in = connection.getInputStream();

最后调用disconnect()关闭HTTP连接：

connection.disconnect();

下面新建一个名为NetworkTest的空活动，调试一下上面的知识点，
修改对应的xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".NetworkTest">

    <Button
        android:id="@+id/send_request"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Send Request"/>

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <TextView
            android:id="@+id/response_text"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
    </ScrollView>

</LinearLayout>

以上，

ScrollView用于滚动查看内容；
Button用来发送HTTP请求；
TextView用来显示服务器返回的数据；

接着修改NetworkTest.java：

public class NetworkTest extends AppCompatActivity implements View.OnClickListener{

    TextView responseText;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_network_test);

        Button sendRequest = (Button) findViewById(R.id.send_request);
        responseText = (TextView) findViewById(R.id.response_text);
        sendRequest.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        if(v.getId() == R.id.send_request){
            sendRequestWithHttpURLConnection();
        }
    }

    private void sendRequestWithHttpURLConnection() {

        new Thread(new Runnable() {
            @Override
            public void run() {
                HttpURLConnection connection = null;
                BufferedReader reader = null;

                try {
                    URL url = new URL("https://hao.360.cn/");
                    connection = (HttpURLConnection)url.openConnection();

                    connection.setRequestMethod("GET");

                    connection.setConnectTimeout(8000);
                    connection.setReadTimeout(8000);

                    InputStream in = connection.getInputStream();

                    //下面对获取的输入流进行读取
                    //InputStreamReader赋值给BufferedReader让其来读
                    reader = new BufferedReader(new InputStreamReader(in));
                    StringBuilder response = new StringBuilder();
                    String line;
                    //一行一行地读取并加进stringbuilder
                    while((line = reader.readLine()) != null){
                        response.append(line);
                    }
                    showResponse(response.toString());
                    Log.d("NetworkTest:  ", response.toString());
                } catch (IOException e) {
                    e.printStackTrace();
                }finally{
                    if(reader !=null){
                        try {
                            reader.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if(connection !=null){
                        connection.disconnect();
                    }
                }
            }
        }).start();

    }

    private void showResponse(final String response) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                responseText.setText(response);
            }
        });
    }
}

sendRequestWithHttpURLConnection()中：
开启一个子线程，
在子线程里使用HttpURLConnection发出一条HTTP请求，
请求的目标地址就是百度的首页；
接着用BufferedReader读取返回的输入流，
转成string传给showResponse()
showResponse()中通过runOnUiThread()将返回的数据显示到界面上；

关于runOnUiThread()方法，
因为Android不允许在子线程中进行UI操作，
我们需要通过这个方法在子线程中将线程切换到主线程，
然后再更新UI元素。

运行效果如下：

注：
如网址不正确，
会出现
NetworkSecurityConfig: No Network Security Config specified, using platform default的提示。
另外，用手机热点也是如此！！！
只有稳定PC端接线网络或其热点才可顺利使用！！

服务器返回的就是这些HTML代码，
只是通常浏览器都会将这些代码解析成漂亮的网页再展示出来；
如果想提交数据给服务器，
只需将HTTP请求方法改成POST，
并在获取输入流之前把要提交的数据写出即可。
每条数据都要以键值对的形式存在，
数据与数据之间用“&”符号隔开，如提交用户名和密码：

connection.setRequestMethod("POST");
DataOutputStream out  = new DataOutputStream(connection.getOutputStream());
out.writeBytes("username=admin&password=123456");

2. 使用OkHttp

OkHttp由Square公司开发，其不仅在接口封装上面做的简单易用，
就连在底层实现上也是自成一派，
比起原生的HttpURLConnection，可以说是有过之而无不及，
现在已经成了广大Android开发者的首选网络通信库。

OkHttp项目主页地址：https://github.com/square/okhttp
使用之前，需添加OkHttp库依赖，
打开app/buid.gradle，在dependencies闭包中添加如下内容：

    implementation("com.squareup.okhttp3:okhttp:3.14.0")

添加此依赖，会自动下载两个库：OkHttp库、Okio库（是前者的通信基础）。

注意，添加前最好是访问一下OkHttp项目主页查看当前最新的版本是多少，再在gradle处添加依赖；

下面是OkHttp具体用法

首先，需要创建OkHttpClient实例，如下：

OkHttpClient client = new OkHttpClient();

接下来，如想发起一条HTTP请求，需创建Request对象：

Request request = new Request.Builder().build();

当然上述代码只是创建一个空的Request对象，
需要在build()方法之前可连缀很多其他方法丰富此Request对象。

Request request = new Request.Builder()
.url("https://www.baidu.com")
.build();

之后调用OkHttpCilent的newCall()方法创建一个Call对象，
并调用它的execute()方法发送请求，
并获取服务器返回的数据：

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

request存请求；
newCall接收request
execute执行request
Response对象接收服务器返回的数据；

下面得到返回的具体内容

String responseData = response.body().string();

如果发起一条POST请求，会比GET复杂些；

需先构建RequestBody对象存放待提交的参数：

RequestBody requestBody = new FormBody.Builder()
.add("username", "admin")
.add("password", "123456")
.build();

然后在Request.Builder中以RequestBody对象为传入的参数调用post()方法，：

Request request = new Request.Builder()
.url("http://www.baidu.com")
.post(requestBody)
.build();

接下来的操作就和GET请求一样了，
调用execute()方法发送请求并获取服务器返回的数据即可。

现在改用OkHttp的方式把刚刚NewworkTest的内容再实现一遍：

    @Override
    public void onClick(View v) {
        if(v.getId() == R.id.send_request){
//            sendRequestWithHttpURLConnection();
            sendRequestWithOkHttp();
        }
    }

private void sendRequestWithOkHttp() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    OkHttpClient client = new OkHttpClient();

                    Request request = new Request.Builder()
                            .url("https://hao.360.cn/")
                            .build();

                    Response response = client.newCall(request).execute();
                    String responseData = response.body().string();
                    showResponse(responseData);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }).start();
    }

    private void showResponse(final String response) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                responseText.setText(response);
            }
        });
    }

运行时有可能出现下面的问题，解决方法是把gradle中minsdk改成26以上即可：

运行效果图：

3.解析XML格式数据

通常，每个需要访问网络的应用程序都会有一个自己的服务器，
我们可以向服务器提交数据或者从服务器上获取数据；
为了双方能够快速知道文本的用途，一般在网络传输的数据都是格式化后的；
这种数据会有一定的结构规格和语义；
当另一方收到数据消息之后就可以按照相同的结构规格进行解析，从而去除他想要的那部分内容；

搭建一个本地服务器

在网络上传输数据最常用的格式有两种：XML和JSON

在开始学习这两种数据格式之前，
我们还需要搭建一个本地服务器，

进度大概进行到
可以在本地服务器文件夹下放置文件，
然后在本地浏览器可以访问即可；

这里提供两种方法：

可以使用单模块原生的本地服务器Apache，
具体的操作我之前已经写过一篇详细的博文：

本地模拟服务器开发与交互——Apache服务器填坑之路（下载、安装、使用demo、卸载）

博文剪影1

博文剪影2

或者学过PHP的朋友也可以使用PhpStudy集成环境（中的Apache模块）来做服务器，具体的相关我也写过相关的博文哈：

PHPStudy的话，在如下文件途径放下文件即可：

文件内容：

<apps>
    <app>
        <id>1</id>
        <name>Google Maps</name>
        <version>1.0</version>
    </app>
    <app>
        <id>2</id>
        <name>Chrome</name>
        <version>2.1</version>
    </app>
    <app>
        <id>3</id>
        <name>Google Play</name>
        <version>2.3</version>
    </app>
</apps>

接着浏览器键入localhost/get_data.xml即可访问：

当然，键入127.0.0.1/get_data.xml也是可以的：

解析XML格式数据有很多方式，Pull和SAX解析是常用的两种。

3.1 Pull解析方式

这里我们依旧在NetworkTest 这个活动上面做开发，重用方才网络通信的代码，把重心放在XML数据解析上；
以上，我们已经准备好XML格式的数据，
现在编写代码从中解析出我们想要得到的那部分内容；

修改NetworkTest.java：

@Override
    public void onClick(View v) {
        if(v.getId() == R.id.send_request){
//            sendRequestWithHttpURLConnection();
            sendRequestWithOkHttp();
        }
    }

    private void sendRequestWithOkHttp() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    OkHttpClient client = new OkHttpClient();

                    //http://10.0.2.2/对于模拟器来说是电脑本机IP地址**
                    Request request = new Request.Builder()
                            .url("http://47.100.78.251/testPackage/get_data.xml")
                            .build();

                    Response response = client.newCall(request).execute();
                    String responseData = response.body().string();

                    parseXMLWithPull(responseData);//解析服务器返回的数据**

//                    showResponse(responseData);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }).start();
    }

    private void parseXMLWithPull(String xmlData) {
        try{
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();//获取一个XmlPullParserFactory 实例
            XmlPullParser xmlPullParser = factory.newPullParser();//借助XmlPullParserFactory 实例得到 XmlPullParser对象
            xmlPullParser.setInput(new StringReader(xmlData));//XmlPullParser对象 setInput 把服务器返回的数据传入即可开始解析

            int eventType = xmlPullParser.getEventType();//通过getEventType()得到当前的解析事件
            String id = "";
            String name = "";
            String version = "";

            //如果不到文末
            //解析事件不为XmlPullParser.END_DOCUMENT，说明解析工作没完成
            responseText.setText("");

            while(eventType != XmlPullParser.END_DOCUMENT){
                //解析事件不为XmlPullParser.END_DOCUMENT，说明解析工作没完成

                String nodeName = xmlPullParser.getName();//获取当前结点名字

                switch (eventType) {
                    //开始解析某个节点
                    case XmlPullParser.START_TAG:
                        if ("id".equals(nodeName)) {
                            id = xmlPullParser.nextText();//获取节点具体内容
                        } else if ("name".equals(nodeName)) {
                            name = xmlPullParser.nextText();
                        } else if ("version".equals(nodeName)) {
                            version = xmlPullParser.nextText();
                        }
                        break;
                    //完成解析某个节点
                    case XmlPullParser.END_TAG:
                        if ("app".equals(nodeName)) {

                            //解析完一个app节点后打印获取到的内容
                            String finalId = id;
                            String finalName = name;
                            String finalVersion = version;

                            runOnUiThread(new Runnable() {
                                @Override
                                public void run() {
                                    responseText.append("MainActivity: id is " + finalId + "\n");
                                    responseText.append("MainActivity: name is " + finalName + "\n");
                                    responseText.append("MainActivity: version is " + finalVersion + "\n");
                                }
                            });

                        }
                        break;
                    default:
                        break;
                }
                eventType = xmlPullParser.next();//获取下一个解析事件
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Pull解析的使用思路是：

通过XmlPullParserFactory等一系列API，
得到一个XmlPullParser实例，
再把数据
传给XmlPullParser实例xmlPullParser.setInput(new StringReader(xmlData));
接着就可以开始解析了；

把XML的文末标志、起始标签以及结束标签，
约定为一个事件int eventType = xmlPullParser.getEventType();

文末标志事件用于判断文件是否解析完，
起始标签事件用于判断以及获取标签节点中的内容，
结束标签事件则用于判断以及
去实现一个解析阶段结束后的业务逻辑；

3.2 SAX解析方式

除了Pull解析，SAX解析也是一种常用的解析方式，
其用法比Pull解析复杂一些，
但语义上会更清楚；

用法：

新建一个类继承自DefaultHandler，并重写父类5个方法。

public class MyHandler extends DefaultHandler {

    @Override
    public void startDocument() throws SAXException {
        super.startDocument();
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        super.startElement(uri, localName, qName, attributes);
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        super.characters(ch, start, length);
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        super.endElement(uri, localName, qName);
    }

    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
    }
}

startDocument()在开始XML解析时候调用；
startElement()在开始解析某个节点时调用；
characters()在获取节点中的内容时候调用；
endElement()在完成解析某个节点的时候调用；
endDocument()在完成整个XML解析时调用；

startElement()、characters()、endElement()三个方法是有参数的，
从XML中解析的数据会以参数的形式传入到这些方法中；
在获取节点中的内容时，
characters()方法可能会被调用多次，
一些换行符也被当做内容解析出来，
我们需要针对这种情况在代码中做好控制；

实践

新建一个类继承自DefaultHandler，并重写父类5个方法：
（注意代码中的注释）

public class ContentHandler extends DefaultHandler {

    public String nodeName;

    //面向XML文件配置全局属性
    public StringBuilder id;

    public StringBuilder name;

    public StringBuilder version;

    @Override
    public void startDocument() throws SAXException {
        id = new StringBuilder();
        name = new StringBuilder();
        version = new StringBuilder();
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        //记录当前节点
        nodeName = localName;
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        //根据当前的节点名判断将内容添加到哪一个StringBuilder对象中
        if ("id".equals(nodeName)){
            id.append(ch, start, length);
        }else if ("name".equals(nodeName)){
            name.append(ch, start, length);
        }else if ("version".equals(nodeName)){
            version.append(ch, start, length);
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        if ("app".equals(localName)){

            // !!!!!!!!!!!
            //id\name\version中可能包含回车或换行符，需调用trim()方法除去
            // !!!!!!!!!!!
            Log.d("ContentHandler", "id is " + id.toString().trim());
            Log.d("ContentHandler", "name is " + name.toString().trim());
            Log.d("ContentHandler", "version is " + version.toString().trim());
            //最后要将StringBuilder清空，避免影响下一次内容读取
            id.setLength(0);
            name.setLength(0);
            version.setLength(0);
        }
    }

    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
    }
}

修改MainActivity：

@Override
    public void onClick(View v) {
        if(v.getId() == R.id.send_request){
//            sendRequestWithHttpURLConnection();
            sendRequestWithOkHttp();
        }
    }

    private void sendRequestWithOkHttp() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    OkHttpClient client = new OkHttpClient();

                    //http://10.0.2.2/对于模拟器来说是电脑本机IP地址**
                    Request request = new Request.Builder()
                            .url("http://47.100.78.251/testPackage/get_data.xml")
                            .build();

                    Response response = client.newCall(request).execute();
                    String responseData = response.body().string();

//                    parseXMLWithPull(responseData);//解析服务器返回的数据**

                    parseXMLWithSAX(responseData);//解析服务器返回的数据**

//                    showResponse(responseData);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }).start();
    }

    private void parseXMLWithSAX(String xmlData) {
        try {
            SAXParserFactory factory = SAXParserFactory.newInstance();
            XMLReader xmlReader = factory.newSAXParser().getXMLReader();
            ContentHandler handler = new ContentHandler();
            //将ContentHandler的实例设置到XMLReader中
            xmlReader.setContentHandler(handler);
            //开始执行解析
            xmlReader.parse(new InputSource(new StringReader(xmlData)));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

运行程序，点击按钮，查看日志：

除了Pull和SAX，还有DOM解析方式可用；

4.解析JSON数据

JSON的体积比XML更小，网络传输更省流量，
但语义性差，不如XML直观。
在对应的服务器目录下，新建一个get_data.json文件，内容如下：

[{"id":"5","name":"Clash of Clans","version":"5.5"},
{"id":"6","name":"Boom Beach","version":"7.0"},
{"id":"7","name":"Clash Royale","version":"3.5"}]

4.1使用JSONObject

解析JSON数据也有很多方法，可使用官方的JSONObject，
谷歌的开源库GSON，
或第三方的开源库如Jackson、FastJSON等.
我们在服务器中定义的json文件get_data.json的内容是一个JSON数组，
因此这里获取到服务器的数据之后，
直接将数据传入到一个JSONArray对象中；
然后循环遍历这个JSONArray，
从中取出的每一个元素都是一个JSONObject对象；
这个JSONObject对象又会包含id、name和version这些数据，
即我们定义的json文件中的键值；
接着只要调用getString()将这些数据取出来即可；

使用JSONObject，修改MainActivity：

@Override
    public void onClick(View v) {
        if(v.getId() == R.id.send_request){
//            sendRequestWithHttpURLConnection();
            sendRequestWithOkHttp();
        }
    }

    //子线程中进行！！！！！！！！！
    private void sendRequestWithOkHttp() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    OkHttpClient client = new OkHttpClient();

                    //http://10.0.2.2/对于模拟器来说是电脑本机IP地址**
                    Request request = new Request.Builder()
                            .url("http://47.100.78.251/testPackage/get_data.json")
                            .build();

                    Response response = client.newCall(request).execute();
                    String responseData = response.body().string();

                    parseJSONWithJSONObject(responseData);

//                    parseXMLWithPull(responseData);//解析服务器返回的数据**

//                    parseXMLWithSAX(responseData);//解析服务器返回的数据**

//                    showResponse(responseData);
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (JSONException e) {
                    e.printStackTrace();
                }

            }
        }).start();
    }

    private void parseJSONWithJSONObject(String responseData) throws JSONException {
        //我们在服务器中定义的json文件get_data.json的内容是一个JSON数组
        JSONArray jsonArray = new JSONArray(responseData);


        responseText.setText("");
        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);

            String id = jsonObject.getString("id");
            String name = jsonObject.getString("name");
            String version = jsonObject.getString("version");

            runOnUiThread(new Runnable() {
                @Override
                public void run() {

                    responseText.append("MainActivity: id is " + id + "\n");
                    responseText.append("MainActivity: name is " + name + "\n");
                    responseText.append("MainActivity: version is " + version + "\n");
                }
            });

        }
    }

运行程序：

4.2 使用GSON

添加依赖：

    implementation 'com.google.code.gson:gson:2.8.5'

它主要可以将一段JSON格式的字符串自动映射成一个对象（定义一个类对应），
不需手动编写代码解析。
比如说一段json格式的数据如下所示：
{"name":"Tom","age":20}
则定义一个Person类，
加入name和age这两个字段；

面向需要解析的json数据定义JavaBean类，
如果一个json数据有十几几十个键值对，
而我们的业务只需要取其中的5个键值，
那这个JavaBean类，就定义需要的5个字段即可，
Gson会将json数据字符串，
根据我们定义的JavaBean类，
提取出相应的数据并映射成对应的List；
json字符串中有多少套JavaBean类字段对应的键值，
映射得到的List的size就有多少；

接着简单调用如下代码即可将JSON数据
自动解析成一个Person对象了：

Gson gson = new Gson()；
Person person = gson.fromJson(jsonData, Person.class);

如果需要解析的是一段JSON数组会稍微麻烦一点，
需要借助TypeToken将期望解析成的数据类型传入到fromJson()方法中，如：
List<Person> people = gson.fromJson(jsonData, new TypeToken<List<Person>>(){}.getType());

基本用法就如上所述了，
接下来用GSON解析一下一开始的数据；

首先新建一个App类：

public class App {
    private String id;
    private String name;
    private String version;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }
}

修改MainActivity：


    @Override
    public void onClick(View v) {
        if(v.getId() == R.id.send_request){
//            sendRequestWithHttpURLConnection();
            sendRequestWithOkHttp();
        }
    }

    //！！！！！！！！
    //注意这里在子线程中进行！！
    // UI更新需要切到主线程
    // ！！！！！！！
    private void sendRequestWithOkHttp() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    OkHttpClient client = new OkHttpClient();

                    //http://10.0.2.2/对于模拟器来说是电脑本机IP地址**
                    Request request = new Request.Builder()
                            .url("http://47.100.78.251/testPackage/get_data.json")
                            .build();

                    Response response = client.newCall(request).execute();
                    String responseData = response.body().string();

//                    parseJSONWithJSONObject(responseData);

                    parsJSONWithGSON(responseData);

//                    parseXMLWithPull(responseData);//解析服务器返回的数据**

//                    parseXMLWithSAX(responseData);//解析服务器返回的数据**

//                    showResponse(responseData);
                } catch (IOException e) {
                    e.printStackTrace();
                }
//                catch (JSONException e) {
//                    e.printStackTrace();
//                }

            }
        }).start();
    }

    private void parsJSONWithGSON(String jsonData) {
        Gson gson = new Gson();
        List<App> appList = gson.fromJson(jsonData, new TypeToken<List<App>>(){}.getType());

        for (App app : appList) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {

                    responseText.append("MainActivity: id is " + app.getId() + "\n");
                    responseText.append("MainActivity: name is " + app.getName() + "\n");
                    responseText.append("MainActivity: version is " + app.getVersion() + "\n");
                }
            });
        }
    }

运行程序，效果同上。

5.网络编程的最佳实践

（方法提取）
应用程序很可能会在许多地方都使用网络功能，
而发送HTTP请求的代码基本相同，
所以我们不能每次都去编写一遍发送HTTP请求的代码，
通常应该把通用的网络操作提取到一个公共类里，
并提供一个静态方法，
当想要发起网络请求的时候，
只需要简单地调用一下这个方法即可。

（耗时操作）
另外，
网络请求通常都是属于耗时操作，
我们提取的发送HTTP请求的方法内部
如果没有开启子线程，
则有可能导致在调用的时候使得主线程阻塞，
这里则需开启子线程来发起HTTP请求，

（数据返回）
另外还要考虑到，
如果我们在一个请求方法内部的
开启了一个子线程来发送HTTP请求，
那服务器响应的数据是无法进行返回的，
所有的耗时逻辑都是在子线程里进行的，
这个请求方法会在服务器还没来得及响应的时候就执行结束了，
当然也就无法返回响应的数据了；

遇到这种既需要子线程来处理耗时操作，
又要求能实时接收到服务器响应到的数据的情况，
可以考虑使用Java的回调机制来实现：

实现一个接口就是写一个插座，
把封装的东西写进实现接口的类中，
把这个（匿名内部）类赋给回调方法（如setOnClickListener()）

内部抽象调用，外部具体实现（的方法）;
内部只管调用，
外部只管实现（具体的处理方法、逻辑）！
连接处：
外部实现的方法，
封装在一个匿名内部类接口实现类实例中，
将实例传给抽象调用的工具类的设置方法或者构造方法，
实现内外连接；

这样内部调用的接口方法，
就是源自外部传进来的
接口实例的
(在外部具体实现好的)接口方法（逻辑）；

数据在内部抽象调用时传递给内部未具体实现的接口方法，
这里抽象调用的未具体实现的接口方法实际上在程序运行使用时，
就是外部具体实现的接口及其方法（处理逻辑）；
（来自set传进来的外部实现好诸接口方法的接口实例）
如此一来数据便通过回调机制，
由内而外间接传递给了外部（给外部处理）。

小结：
内部形式抽象调用，
外部具体逻辑实现，
外部实现封装在接口类实例中传进来，
使得内部的形式调用能够调用到了外部的具体逻辑实现；

首先需要定义一个接口，这里取名HttpCallbackListener：
onFinish(String response)
当服务器成功响应请求时调用，参数为服务器返回的数据；
onError(Exception e)
当进行网络操作出现错误时调用，参数记录错误的详细信息；

public interface HttpCallbackListener {
    void onFinish(String response);
    void onError(Exception e);
}

接着新建一个刚刚说的放着提取了通用网络操作的公共类：
listener.onFinish(response.toString());
回调外部传进来的写好的
匿名内部接口类的具体实现好的方法，
这里公共类中抽象调用，
调用公共类方法的地方则具体实现接口类（常用匿名内部类方式实现），
实现好了赋到这里来；

public class HttpUtil {

    public static void sendHttpRequest( final String address, final HttpCallbackListener listener){

        new Thread(new Runnable() {

            @Override
            public void run() {
                HttpURLConnection connection = null;

                try {
                    URL url = new URL(address);

                    connection = (HttpURLConnection) url.openConnection();
                    connection.setRequestMethod("GET");
                    connection.setConnectTimeout(8000);
                    connection.setReadTimeout(8000);
                    connection.setDoInput(true);
                    connection.setDoOutput(true);

                    InputStream in = connection.getInputStream();
                    //对获取到的输入流进行读取
                    BufferedReader reader = new BufferedReader(new InputStreamReader(in));

                    StringBuilder response = new StringBuilder();
                    String line;

                    while ((line = reader.readLine()) != null){
                        response.append(line);
                    }

                    if (listener != null){
                        
                        //回调onFinish方法
                        listener.onFinish(response.toString());
                    }

                } catch (Exception e) {

                    if (listener != null){
                        //回调onError方法
                        listener.onError(e);
                    }
                }finally {
                    if (connection != null){
                        connection.disconnect();
                    }
                }
            }
        }).start();
    }
}

sendHttpRequest()注意点：
- HttpCallbackListener参数；
- 内部开启子线程，子线程中进行具体的网络操作；
  子线程中是无法通过return语句来返回数据的，
  因此这里将服务器响应的数据
  传入了HttpCallbackListener的onFinish()方法中，
  在调用者（调用公共类方法者）处的接口（匿名）实现类中处理，
  调用刚刚说的在外部（调用者处）
  实现好的接口（匿名）实现类实例中的具体的onFinish()方法；
  将异常原因
  传入了HttpCallbackListener的onError()方法中，
  在调用者（调用公共类方法者）处的接口（匿名）实现类中处理，
  调用刚刚说的在外部（调用者处）
  实现好的接口（匿名）实现类实例中的具体的onError()方法；
公共类调用案例：（如上所述）利用回调机制将响应数据成功返回给调用方:

String address = "http://www/baidu.com";
HttpUtil.sendHttpRequest(address, new HttpCallbackListener(){
            @Override
            public void onFinish(String response){
                //在这里根据返回内容执行具体的逻辑
            }
            @Override
            public void onError(Exception e){
                //在这里对异常情况进行处理
            }
        });

使用HttpURLConnection的写法总体比较复杂；
使用OkHttp会简单一些；
在HttpUtil中加入一个sendOkHttpRequest()方法：

public static void sendOkHttpRequest(String address, okhttp3.Callback callback) {
        OkHttpClient client = new OkHttpClient();
        
        Request request = new Request.Builder()
                .url(address)
                .build();

        client.newCall(request).enqueue(callback);
    }

注意：
方法中有一个okhttp3.Callback参数，
这个是OkHttp库中自带的一个回调接口，
类似于我们刚刚自己编写的HttpCallbackListener；

然后在client.newCall()之后，
没有像之前那样直接调用execute()，
而是调用了enqueue()，
并把okhttp3.Callback参数传入，

OkHttp在enqueue()中已经帮我们开好了子线程，
在子线程中去执行HTTP请求，
并将最后的请求结果回调到okhttp3.Callback，
（也就是说，
我们刚刚在sendHttpRequest()做的事情，
子线程、请求、数据返回，
OkHttp都帮我们做好了）

最后，
我们在外部实例化一个接口对象并具体实现方法，
再把接口实例传进来sendOkHttpRequest()，
赋值给对应的enqueue()方法，
完成任务！