我该如何修复'android.os.NetworkOnMainThreadException'错误？

如果在主线程上执行的任何重任务需要花费过多时间，则会发生此异常。

为了避免这种情况，我们可以使用线程或执行器来处理。

Executors.newSingleThreadExecutor().submit(new Runnable() {
    @Override
    public void run() {
        // You can perform your task here.
    }
});

http://api.example.com/stocks                       // ResponseWrapper<String> object containing a
                                                    // list of strings with ticker symbols
http://api.example.com/stocks/$symbol               // Stock object
http://api.example.com/stocks/$symbol/prices        // PriceHistory<Stock> object
http://api.example.com/currencies                   // ResponseWrapper<String> object containing a
                                                    // list of currency abbreviation
http://api.example.com/currencies/$currency         // Currency object
http://api.example.com/currencies/$id1/values/$id2  // PriceHistory<Currency> object comparing the prices
                                                    // of the first currency (id1) to the second (id2)

Retrofit from Square

这是一个优秀的API选择，适用于具有多个端点的API，并允许您声明REST端点，而不必像其他库（如Amazon Ion Java或Volley（网站：Retrofit）一样单独编写代码。

如何将其与财务API一起使用？

文件build.gradle

将以下行添加到您的模块级别的build.gradle文件中：

implementation 'com.squareup.retrofit2:retrofit:2.3.0' // Retrofit library, current as of September 21, 2017
implementation 'com.squareup.retrofit2:converter-gson:2.3.0' // Gson serialization and deserialization support for retrofit, version must match retrofit version

文件 FinancesApi.java

public interface FinancesApi {
    @GET("stocks")
    Call<ResponseWrapper<String>> listStocks();
    @GET("stocks/{symbol}")
    Call<Stock> getStock(@Path("symbol")String tickerSymbol);
    @GET("stocks/{symbol}/prices")
    Call<PriceHistory<Stock>> getPriceHistory(@Path("symbol")String tickerSymbol);

    @GET("currencies")
    Call<ResponseWrapper<String>> listCurrencies();
    @GET("currencies/{symbol}")
    Call<Currency> getCurrency(@Path("symbol")String currencySymbol);
    @GET("currencies/{symbol}/values/{compare_symbol}")
    Call<PriceHistory<Currency>> getComparativeHistory(@Path("symbol")String currency, @Path("compare_symbol")String currencyToPriceAgainst);
}

public class FinancesApiBuilder {
    public static FinancesApi build(String baseUrl){
        return new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build()
                    .create(FinancesApi.class);
    }
}

类 FinancesFragment 代码片段

FinancesApi api = FinancesApiBuilder.build("http://api.example.com/"); //trailing '/' required for predictable behavior
api.getStock("INTC").enqueue(new Callback<Stock>(){
    @Override
    public void onResponse(Call<Stock> stockCall, Response<Stock> stockResponse){
        Stock stock = stockCall.body();
        // Do something with the stock
    }
    @Override
    public void onResponse(Call<Stock> stockCall, Throwable t){
        // Something bad happened
    }
}

假设您正在构建一款社交网络应用，并希望加载朋友的个人资料图片。

build.gradle文件

将以下行添加到您的模块级别的build.gradle文件中：

implementation 'com.android.volley:volley:1.0.0'

文件 ImageFetch.java

Volley需要比Retrofit更多的设置。您需要创建一个类来设置RequestQueue、ImageLoader和ImageCache，但这并不太困难：

public class ImageFetch {
    private static ImageLoader imageLoader = null;
    private static RequestQueue imageQueue = null;

    public static ImageLoader getImageLoader(Context ctx){
        if(imageLoader == null){
            if(imageQueue == null){
                imageQueue = Volley.newRequestQueue(ctx.getApplicationContext());
            }
            imageLoader = new ImageLoader(imageQueue, new ImageLoader.ImageCache() {
                Map<String, Bitmap> cache = new HashMap<String, Bitmap>();
                @Override
                public Bitmap getBitmap(String url) {
                    return cache.get(url);
                }
                @Override
                public void putBitmap(String url, Bitmap bitmap) {
                    cache.put(url, bitmap);
                }
            });
        }
        return imageLoader;
    }
}

文件 user_view_dialog.xml

将以下内容添加到您的布局XML文件中以添加图像：

<com.android.volley.toolbox.NetworkImageView
    android:id="@+id/profile_picture"
    android:layout_width="32dp"
    android:layout_height="32dp"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    app:srcCompat="@android:drawable/spinner_background"/>

文件 UserViewDialog.java

将以下代码添加到onCreate方法（Fragment，Activity）或构造函数（Dialog）中：

NetworkImageView profilePicture = view.findViewById(R.id.profile_picture);
profilePicture.setImageUrl("http://example.com/users/images/profile.jpg", ImageFetch.getImageLoader(getContext());

Picasso

Picasso是来自Square的另一个优秀库。请查看网站以获取一些很棒的示例。

简单来说，

不要在UI线程中进行网络操作

例如，如果你发起一个HTTP请求，那就是一个网络操作。

解决方案：

1. 创建一个新的线程
2. 或者使用AsyncTask类

方式：

将所有工作放入：

1. 新线程的run()方法中
2. 或者AsyncTask类的doInBackground()方法中。

但是：

当你从网络响应中获取一些内容并想在视图中显示它（比如在TextView中展示响应消息），你需要回到UI线程。

如果不这样做，你将会得到ViewRootImpl$CalledFromWrongThreadException异常。

如何实现：

1. 使用AsyncTask时，从onPostExecute()方法中更新视图

根据情况，有一些方法可供选择

Java Thread 或 Android HandlerThread：

Java 线程仅可使用一次，并在执行其运行方法后终止。

HandlerThread 是一个方便的类，用于启动具有 looper 的新线程。

AsyncTask（在 API 级别 30 中已弃用）

AsyncTask 被设计为 Thread 和 Handler 周围的辅助类，不构成通用的线程框架。AsyncTasks 应该理想地用于短操作（最多几秒钟）。如果您需要使线程长时间运行，强烈建议您使用 java.util.concurrent 包提供的各种 API，例如 Executor、ThreadPoolExecutor 和 FutureTask。

由于 main 线程垄断了 UI 组件，因此无法访问某些 View，这就是 Handler 出现的原因

[Executor framework]

ThreadPoolExecutor类实现了ExecutorService，可以对线程池进行精细控制（例如，核心池大小，最大池大小，保持活动时间等）。

ScheduledThreadPoolExecutor是扩展了ThreadPoolExecutor的一个类。它可以在给定延迟后或定期安排任务。

FutureTask

FutureTask执行异步处理，但如果结果尚未准备好或处理尚未完成，则调用get()将阻塞线程。

AsyncTaskLoader

AsyncTaskLoader可以解决AsyncTask固有的许多问题。

IntentService

这是在Android上长时间运行处理的默认选择，一个很好的例子是上传或下载大文件。即使用户退出应用程序，上传和下载也可能会继续进行，您肯定不希望在进行这些任务时阻止用户使用应用程序。

JobScheduler

实际上，您必须创建一个服务，并使用JobInfo.Builder创建一个作业，该作业指定了运行服务的条件。

RxJava

通过使用可观察序列来组合异步和基于事件的程序的库。

协程 （Kotlin）

其主要要点是，它使异步代码看起来非常像同步代码。

阅读更多内容，请点击这里、这里、这里以及这里。

Kotlin

如果您正在使用Kotlin，则可以使用协程：

fun doSomeNetworkStuff() {
    GlobalScope.launch(Dispatchers.IO) {
        // ...
    }
}

已经解释了新的Thread和AsyncTask解决方案。

AsyncTask应该用于短操作。在Android中，正常的Thread不可取。

看看使用HandlerThread和Handler的备选方案。

HandlerThread

方便启动一个具有looper的新线程的类。然后可以使用looper来创建handler类。注意仍然必须调用start()。

Handler:

HandlerThread handlerThread = new HandlerThread("URLConnection");
handlerThread.start();
handler mainHandler = new Handler(handlerThread.getLooper());

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Log.d("Ravi", "Before IO call");
            URL page = new URL("http://www.google.com");
            StringBuffer text = new StringBuffer();
            HttpURLConnection conn = (HttpURLConnection) page.openConnection();
            conn.connect();
            InputStreamReader in = new InputStreamReader((InputStream) conn.getContent());
            BufferedReader buff = new BufferedReader(in);
            String line;
            while ( (line =  buff.readLine()) != null) {
                text.append(line + "\n");
            }
            Log.d("Ravi", "After IO call");
            Log.d("Ravi",text.toString());

        } catch (Exception err) {
            err.printStackTrace();
        }
    }
};
mainHandler.post(myRunnable);

这个有效。我只是把Dr.Luiji的答案简化了一点。

new Thread() {
    @Override
    public void run() {
        try {
            //Your code goes here
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}.start();

Ion.with(context)
.load("http://example.com/thing.json")
.asJsonObject()
.setCallback(new FutureCallback<JsonObject>() {
   @Override
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error
    }
});

StrictMode.ThreadPolicy threadPolicy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(threadPolicy);

如果需要的话，您可以创建一个简单的处理程序并更新主线程。

Runnable runnable;
Handler newHandler;

newHandler = new Handler();
runnable = new Runnable() {
    @Override
    public void run() {
         try {
            //update UI
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
};
newHandler.post(runnable);

要停止线程，请使用以下方法：

newHandler.removeCallbacks(runnable);

欲了解更多信息，请访问：无痛线程处理

Android不允许在主线程上执行长时间操作。

因此，只需使用不同的线程，并在需要时将结果发送到主线程即可。

new Thread(new Runnable() {
        @Override
        public void run() {
            /*
            // Run operation here
            */
            // After getting the result
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    // Post the result to the main thread
                }
            });
        }
    }).start();