正文

Android 网络教程: 开始

IP云
IP云V管理员/3 阅读
12/02
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

原文：Android Networking Tutorial: Getting Started

作者：Eunice Obugyei

译者：kmyhy

从 API 级别 1 开始，网络始终是 Android 中最大主角。大部分 app 都不是单独运行的，它们会连接到网络服务检索数据或者进行其他网络操作。

在本教程中，你会创建一个简单 app ，连接 GitHub API 查找并显示代码库列表。

在此过程中，你会学到：

  • 如何检查网络连接状态
  • 如何进行网络操作
  • 如何利用开源库进行网络操作

注意：本教程假定你懂得基本的 Android 开发。如果你完全不懂，请先阅读我们的Android 初学者教程，以具备一定的基础。

开始

下载开始项目，解压缩。在 Android Studio 快速启动菜单中，用 Open an existing Android Studio project 打开项目：

也可以用 File\Open 菜单，找到并选择开始项目的文件夹。

打开 Util.java 看看，这个文件包含了一个助手方法，将一个 JSON 字符串转化成一个 repository 对象的 list。Repository.java 是模型类，用于代表一个 Github 存储库。

运行项目，看看你还需要做些什么：

需要用到的权限

要在 Android 中进行网络请求，app 必须拥有相应权限。

打开 manifest/AndroidManifest.xml，在 application 标签之前添加几个权限： 

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

ACCESS_NETWORK_STATE 权限允许 app 检查设备的网络状态，INTERNET 权限允许 app 访问 Internet。

在进行任何网络请求之前，先检查一下设备是否已经连上了网络:]

检查网络连接

在编写任何 Java 代码之前，你需要让 Android Studio 自动插入 import 语句，节省你手动添加的时间。

进入 Android Studio\Preferences\Editor\General\Auto Import, 菜单，选择 Add unambiguous imports on the fly 勾选框，然后点击 OK。

打开 MainActivity.java，新增方法： 

private boolean isNetworkConnected() {
  ConnectivityManager connMgr = (ConnectivityManager)
   getSystemService(Context.CONNECTIVITY_SERVICE); // 1
  NetworkInfo networkInfo = connMgr.getActiveNetworkInfo(); // 2
  return networkInfo != null && networkInfo.isConnected(); // 3
}

isNetworkConnected() 方法通过下列步骤来检查设备是否有一个有效的互联网连接：

  • 从当前 app 上下文中获得一个 ConnectivityManager 对象。
  • 获得一个 NetworkInfo 对象，它代表了当前的网络连接。如果没有联网则这个对象为 null。
  • 判断是否有有效的网络连接，同时设备已经连上。

如果设备未连接网络，用一个 alert 提示用户连接网络是一个不错的注意。

下列 import 语句需要手动输入，因为 Android Studio 无法判断应该 include 

import android.content.DialogInterface;
import android.support.v7.app.AlertDialog;

将 onCreate() 方法中的 showListFragment(new ArrayList()); 一句替换为： 

if (isNetworkConnected()) {
  mProgressDialog = new ProgressDialog(this);
  mProgressDialog.setMessage("Please wait...");
  mProgressDialog.setCancelable(false);
  mProgressDialog.show();

  startDownload();
} else {
  new AlertDialog.Builder(this)
    .setTitle("No Internet Connection")
    .setMessage("It looks like your internet connection is off. Please turn it " +
    "on and try again")
    .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int which) {
    }
  }).setIcon(android.R.drawable.ic_dialog_alert).show();
}

如果设备已联网，会显示进度条并调用 startDownload()。如果未联网，显示一个 alert 给用户。

运行 app，如果设备已连上网，app 会显示一个 ProgressDialog：

然后关掉设备的网络连接重新点开 app。app现在显示一个 alert 提示网络连接错误：

注意：如果使用模拟器，请阅读我们的Android Studio 2 的 What’s new中关于 Android Emulator 2.0 一节。

检查网络类型

如果你的 app 会抓取海量数据，你可能想将网络连接限制在某种类型，比如 wifi。这就可以调用 NetworkInfo 对象的 getType()。

在 MainActivity 中新增方法： 

private boolean isWifiConnected() {
  ConnectivityManager connMgr = (ConnectivityManager)
              getSystemService(Context.CONNECTIVITY_SERVICE);
  NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
  return networkInfo != null && (ConnectivityManager.TYPE_WIFI == networkInfo.getType()) && networkInfo.isConnected();
}

上述方法在设备使用 wifi 网络时返回 true。

将 onCreate() 方法中的 isNetworkConnected() 调用语句替换为： 

isWifiConnected()

运行 app；如果设备连接的是 wifi 网络，app 会显示出下载进度：

关掉 wifi（但开着蜂窝数据流量），重启 app。你会看到网络连接错误的 alert 又出现了：

进行网络请求

在 Android 开发中，最好将需要长时间运行、可能导致 app 挂起的任务和 UI 线程分开来操作。而网络操作，就属于这种类型的任务。

从 Android 3.0(Honeycomb)开始，如果网络操作放在 UI 线程中进行，系统会抛出一个NetworkOnMainThreadException 异常并崩溃。

AsyncTask 类允许你从后台执行异步任务，然后将结果发布到 UI 线程，不需要进行任何线程操作。

因为 AyncTask 是一个抽象类，你必须子类化它才能使用。

在某个 package 上（这里是 reposearch）用 File/New/Java Class 新建一个类:

在新建类窗口，输入类名：DownloadRepoTask 然后点 OK:

将类声明为如下内容： 

public class DownloadRepoTask extends AsyncTask<String, Void, String> {
  // 1
  @Override
  protected String doInBackground(String... params) {
    return null;
  }

  // 2
  @Override
  protected void onPostExecute(String result) {

  }
}

代码解释如下：

AsyncTask 能够在后台执行（长时间）操作并将结果发布给 UI 线程，同时不需要你编写任何线程代码。 DownloadRepoTask 有两个关键字 extends AsyncTask。在尖括号中的第一个参数指明的是传递给 doInBackground 方法的输入参数的类型，第三个参数指明 onPostExecute 方法中返回的数据的类型（即 result 参数），第二个参数指明了 onProgressUpdate 方法返回值类型，这个方法我们没有用到，因此我们将它设置为 Void。

  1. doInBackground() 是你要执行的后台任务代码的地方——这里，也就是数据的下载。
  2. 当后台任务完成，onPostExecute() 调用并将执行结果返回给你。

在MainActivity.java 的 startDownload() 方法中添加： 

new DownloadRepoTask().execute("https://api.github.com/repositories");

这里创建了一个 DownloadRepoTask 类，用所需的参数调用 execute 方法。

连接到一个网络 URL

打开 DownloadRepoTask.java 新增方法： 

private String downloadData(String urlString) throws IOException {
  InputStream is = null;
  try {
    URL url = new URL(urlString);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setRequestMethod("GET");
    conn.connect();

    return null;
  } finally {
    if (is != null) {
      is.close();
    }
  }
}

上述代码创建了一个对指定 URL 资源的连接并打开它。

将 doInBackground() 方法的 return 语句替换为： 

try {
  return downloadData(params[0]);
} catch (IOException e) {
  e.printStackTrace();
  return null;
}

代码中调用了 downloadData() 方法，将 URL 传递这个方法。这个 URL 是你在调用 AyncTask 的 excute 方法时传入的。

检索 repository

我们已经创建了一个到资源的连接，可以检索数据了。通过 HttpURLConnection 的 getInputStream() 方法你获得了封装成 InputStream 类型的数据。

在 DownloadRepoTask.java 类中，在 downloadData 方法的返回语句之前添加： 

is = conn.getInputStream();

一个 InputStream 对象是一个可读的字节源，这里，它是从 GitHub 返回的 JSON 对象，我们对它进行解码。

在 DownloadRepoTask.java 中新增方法： 

private String convertToString(InputStream is) throws IOException {
  BufferedReader r = new BufferedReader(new InputStreamReader(is));
  StringBuilder total = new StringBuilder();
  String line;
  while ((line = r.readLine()) != null) {
    total.append(line);
  }
  return new String(total);
}

convertToString() 方法用一个 StringBuilder 来组装 input stream 中的字符串。

在 downloadData() 方法中，将 return 语句改成： 

return convertToString(is);

我们要将下载到的数据传递给启动这个现程的 activity。这里，你可以使用一个监听器，即一种接口来实现。

要创建新接口，选择某个包（这里是 reposearch 包），然后选择 File/New/Java Class。

在创建新类对话框，输入接口名称 DownloadCompleteListener，在 Kind 栏选择 Interface 然后点 OK。

在 DownloadCompleteListener 中新增方法： 

void downloadComplete(ArrayList<Repository> repositories);

在 MainActivity.java 中类声明部分，添加对 DownloadCompleteListener 的实现，变成这个样子： 

public class MainActivity extends AppCompatActivity implements DownloadCompleteListener

然后在 MainActivity 中实现 downloadComplete() 方法： 

@Override
public void downloadComplete(ArrayList<Repository> repositories) {

}

在 DownloadRepoTask.java 中添加一个 DownloadCompleteListener 变量： 

DownloadCompleteListener mDownloadCompleteListener;

然后，添加一个新的构造函数，用一个 DownloadCompleteListener 作为参数，并将它赋给类的 DownloadCompleteListener 变量： 

public DownloadRepoTask(DownloadCompleteListener downloadCompleteListener) {
  this.mDownloadCompleteListener = downloadCompleteListener;
}

在 onPostExecute 中添加代码： 

try {
  mDownloadCompleteListener.downloadComplete(Util.retrieveRepositoriesFromResponse(result));
  }
catch (JSONException e) {
  e.printStackTrace();
}

用 downloadComplete() 方法调用将 result 转换并传递给 DownloadCompleteListener。

打开 MainActivity.java 将 startDownload() 方法改为: 

new DownloadRepoTask(this).execute("https://api.github.com/repositories");

这会开启一个 AsyncTask 并让它连接到 github 的 repositories URL。

在 downloadComplete() 中添加代码： 

showListFragment(repositories);
if (mProgressDialog != null) {
  mProgressDialog.hide();
}

上面的代码获得了 Repository 对象数组，将它们显示给用户，然后隐藏 progress 对话框。

确认设备联网，然后运行 app：

太棒了——你的 app 连上了 Github API，获得了一个 repository 列表并显示出来。

在 Android 中进行网络请求稍微有点繁琐，你不得不打开、关闭连接，处理 InputStrewam 的转换以及将确保将网络操作放到后台线程中进行。

按照套路，应该有某个开源社区的大才出场了，他会用开源库出来帮你处理所有繁琐的细节。

开源来救场了

有许多开源库都能简化 Android 的网络操作。下面稍微介绍一下其中最主流 3 个：

OkHttp

OkHttp 是一个高效的 HTTP 客户端，支持同步/异步调用。它会处理连接的打开、关闭以及 InputStream - string 的转换。它兼容 Android 2.3 以上。

使用 OkHTTP 非常简单，能节省大量网络方面的代码——但有一个例外。

因为 OkHTTP 基于 Java 库构建，而不是 Android 库构建，它没有考虑过 Android 框架的限制，即只允许在主 UI 线程中更新视图。要更新视图，或者将数据 post 回主线程，你必须用 Activity 超类的 runOnUiThread() 方法。

要使用 OkHTTP，你必须先在项目中添加这个依赖。

在 app 模块的 build.gradle 中，添加： 

dependencies {
  ...
  compile 'com.squareup.okhttp3:okhttp:3.1.2'
}

build.gradle 文件变成这个样子：

重新编译项目。

打开 MainActivity.java 新增方法: 

private void makeRequestWithOkHttp(String url) {
  OkHttpClient client = new OkHttpClient();   // 1
  okhttp3.Request request = new okhttp3.Request.Builder().url(url).build();  // 2

  client.newCall(request).enqueue(new okhttp3.Callback() { // 3
    @Override
    public void onFailure(okhttp3.Call call, IOException e) {
      e.printStackTrace();
    }

    @Override
    public void onResponse(okhttp3.Call call, okhttp3.Response response)
    throws IOException {
      final String result = response.body().string();  // 4

      MainActivity.this.runOnUiThread(new Runnable() {
        @Override
        public void run() {
          try {
            downloadComplete(Util.retrieveRepositoriesFromResponse(result));  // 5
          } catch (JSONException e) {
            e.printStackTrace();
          }
        }
      });
    }
  });
}

上述代码进行了这几个动作：

  1. 创建 OkHttpClient 对象。
  2. 构建 OkHttpClient 请求，带上你想连接的 URL 参数。
  3. 将 request 加入请求队列。
  4. 以字符串方式获得 response 对象。
  5. 转换并传递 result 给主线程。

将 startDownload() 方法中的代码替换成： 

makeRequestWithOkHttp("https://api.github.com/repositories");

编译运行 app，结果和之前没有区别。

很简单，不是吗？

Volley

Volley 是一个让网络调用更加快、更加简单的 Android 库。和 OkHTTP 一样，它为了干完所有的脏活累活。比起 OkHttp，它有一个优点，它兼容 Android 1.6 以上。

默认 Volley 以异步方式完成所有调用。因为它是一个 Android 库，它不需要在返回数据给主线程或者刷新视图时做多余的处理。

要使用 Volley，在 app 模块下的 build.gradle 文件中添加依赖： 

dependencies {
  ...
  compile 'com.android.volley:volley:1.0.0'
}

打开 MainActivity.java 新增方法： 

private void makeRequestWithVolley(String url) {

  RequestQueue queue = Volley.newRequestQueue(this); // 1

  StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
              new com.android.volley.Response.Listener<String>() { // 2
    @Override
    public void onResponse(String response) {
      try {
        downloadComplete(Util.retrieveRepositoriesFromResponse(response)); // 3
      } catch (JSONException e) {
        e.printStackTrace();
      }
    }
  }, new com.android.volley.Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
    }
  });
  queue.add(stringRequest);  // 4

}

这个方法完成以下工作：

  1. 创建一个新的 RequestQueue。
  2. 创建一个 StringRequest，带上指定的准备连接的 URL。
  3. 转换、传递 result 到 downloadComplete() 方法。
  4. 将 StringRequest 添加到 RequestQueue。

修改 startDownload() 方法为： 

makeRequestWithVolley("https://api.github.com/repositories");

运行 app，网络请求仍然正常工作。

Retrofit

Retrofit 是一个 Android/Java 库，它能够很好地抓取和上传结构性数据，比如 JSON 和 XML。Retrofit 用 OKHttp 进行 HTTP 请求。和 Volley 不同，在 Volley 中你只能将 JSON 字符创转换成 Repository 对象，Retrofit 则会为你进行这个转换。Retrofit 也允许你指定用下列库进行数据的转换：

  • Gson
  • Jackson
  • Moshi
  • Protobuf
  • Wire
  • Simple XML
  • Scalars (primitives, boxed, and String)

要使用 Retrofit，请在 app 模块的 build.gradle 中添加依赖： 

dependencies {
  ...
  compile 'com.squareup.retrofit2:retrofit:2.0.0-beta4'
  compile 'com.squareup.retrofit2:converter-gson:2.0.0-beta4'
}

然后创建一个新的接口 RetrofitAPI，用它来定义 HTTP 操作。

在 RetrofitAPI 中添加代码： 

@GET("/repositories")
Call<ArrayList<Repository>> retrieveRepositories();

这两句定义了请求方式和要请求的 URL。

在 MainActivity.java 添加 import 语句： 

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

新增方法： 

private void makeRetrofitCalls() {
  Retrofit retrofit = new Retrofit.Builder()
   .baseUrl("https://api.github.com") // 1
   .addConverterFactory(GsonConverterFactory.create()) // 2
   .build();

  RetrofitAPI retrofitAPI = retrofit.create(RetrofitAPI.class); // 3

  Call<ArrayList<Repository>> call = retrofitAPI.retrieveRepositories(); // 4

  call.enqueue(new Callback<ArrayList<Repository>>() {  // 5
    @Override
    public void onResponse(Call<ArrayList<Repository>> call,
                                 Response<ArrayList<Repository>> response) {
      downloadComplete(response.body());  // 6
    }

    @Override
    public void onFailure(Call<ArrayList<Repository>> call, Throwable t) {
      Toast.makeText(MainActivity.this, t.getLocalizedMessage(), Toast.LENGTH_SHORT).show();
    }
  });
}

makeRetrofitCalls() 所做的工作如下:

  • 指定 base URL
  • 指定 GsonConverterFactory 作为转换器，它使用了 Gson 来进行反序列化。
  • 创建一个 RetrofitAPI 的实现。
  • 创建一个请求调用（Request Call)。
  • 将请求回调放入队列。
  • 将 results 传递给 downloadComplete()。

将 startDownload() 方法改成: 

makeRetrofitCalls();

运行 app，列表中的数据和之前一样。

结束

你终于从这个 Android 网络编程速成班中毕业（和幸存下来）了。最终项目从这里下载。

关于教程中的开源项目，请阅读 Android 开发者网站中 [Volley 主页] (https://developer.android.com/training/volley/index.html)，以及 Square 团队在 Github 上的 OkHttp 和 Retrofit。

你还可以参考 Android 开发者网站的网络操作。

希望你喜欢本教程；有任何问题和评论，请在下面留言。

相关阅读

目录[+]