对AsyncTask进行封装，简化繁琐的异步操作

ゝ一世哀愁。 2022-08-04 01:59 212阅读 0赞

对于android的异步操作，往往有二种方法给予我们选择。

**一：Thread+Handler**

**  二:  AsyncTask**

对于二者的相同与异同点，这里并不去进行比较。这里提供一种简化异步操作的方法，供大家参考学习。

代码参考自AndEngine，不过我对它做了一定的修改，让它更适合自己目前项目的开发，感谢open source 能够让我们去学习和阅读那么多优秀的代码。

废话不多说，代码如下：

**CallEarliest<T>:**

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  /\*\* 
2.   \*  
3.   \* 回调接口,回调方法运行于主线程 
4.   \* @ClassName: CallEarliest    
5.   \* @author 姜涛 
6.   \* @version 1.0 2012-1-16 下午11:23:41    
7.   \* @param <T> 
8.   \*/  
9.  **public** **interface** CallEarliest<T> \{  
10.       
11.     **public** **void** onCallEarliest() **throws** Exception;  
12. \}

** Callable<T>:**

/\*\*

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.   \* 回调接口,回调方法运行于异步线程  
2.   \* @ClassName: Callable     
3.   \* @author 姜涛  
4.   \* @version 1.0 2012\-1\-16 下午5:56:42     
5.   \* @param <T>  
6.   \*/  
7.  **public** **interface** Callable<T> \{  
8.        
9.      **public** T call() **throws** Exception;  
10. \}

**Callback<T>:**

/\*\*

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.   \* 回调接口,回调方法运行于主线程  
2.   \* @ClassName: Callback     
3.   \* @author 姜涛  
4.   \* @version 1.0 2012\-1\-16 下午5:58:16     
5.   \* @param <T>  
6.   \*/  
7.  **public** **interface** Callback<T> \{  
8.        
9.      **public** **void** onCallback(**final** T pCallbackValue);  
10. \}

**IProgressListener:**

/\*\*

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  \* 观察者  
2.  \* @ClassName: IProgressListener     
3.  \* @author 姜涛  
4.  \* @version 1.0 2012\-1\-16 下午11:08:40  
5.  \*/  
6.  ublic **interface** IProgressListener \{  
7.    
8.  /\*\* 
9.   \* 进度发生改变的时候调用 
10.  \* @param pProgress 
11.  \*/  
12. **public** **void** onProgressChanged(**final** **int** pProgress);

**ProgressCallable<T>:**

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  /\*\* 
2.   \* 被观察者 
3.   \* @ClassName: ProgressCallable 
4.   \* @author 姜涛 
5.   \* @version 1.0 2012-1-16 下午11:08:52 
6.   \* @param <T> 
7.   \*/  
8.  **public** **interface** ProgressCallable<T> \{  
9.    
10.     /\*\* 
11.      \* 注册观察者对象 
12.      \* @param pProgressListener 
13.      \* @return 
14.      \* @throws Exception 
15.      \*/  
16.     **public** T call(**final** IProgressListener pProgressListener) **throws** Exception;  
17. \}

AsyncTaskUtils:

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  /\*\* 
2.   \* 异步操作工具类 
3.   \* @ClassName: ActivityUtils 
4.   \* @author 姜涛 
5.   \* @version 1.0 2012-1-16 下午11:02:26 
6.   \*/  
7.  **public** **class** AsyncTaskUtils \{  
8.    
9.      /\*\* 
10.      \* 封装的asynctask方法，此方法没有进度框. 
11.      \*  
12.      \* @param pCallEarliest 
13.      \*            运行于主线程，最先执行此方法. 
14.      \* @param mCallable 
15.      \*            运行于异步线程,第二执行此方法. 
16.      \* @param mCallback 
17.      \*            运行于主线程,最后执行此方法. 
18.      \*/  
19.     **public** **static** <T> **void** doAsync(**final** CallEarliest<T> pCallEarliest,  
20.             **final** Callable<T> pCallable, **final** Callback<T> pCallback) \{  
21.   
22.         **new** AsyncTask<Void, Void, T>() \{  
23.   
24.             /\*\* 
25.              \* 首先运行此方法,运行于主线程 
26.              \*/  
27.             @Override  
28.             **protected** **void** onPreExecute() \{  
29.                 **super**.onPreExecute();  
30.                 **try** \{  
31.                     pCallEarliest.onCallEarliest();  
32.                 \} **catch** (Exception e) \{  
33.                     Log.e("error", e.toString());  
34.                 \}  
35.             \}  
36.   
37.             /\*\* 
38.              \* 第二步执行这个方法，这个方法运行在异步线程中 
39.              \*/  
40.             @Override  
41.             **protected** T doInBackground(Void... params) \{  
42.   
43.                 **try** \{  
44.                     **return** pCallable.call();  
45.                 \} **catch** (Exception e) \{  
46.                     Log.e("error", e.toString());  
47.                 \}  
48.                 **return** **null**;  
49.             \}  
50.   
51.             /\*\* 
52.              \* 第三步执行这个方法，运行于主线程 
53.              \*/  
54.             **protected** **void** onPostExecute(T result) \{  
55.                 pCallback.onCallback(result);  
56.             \}  
57.         \}.execute((Void\[\]) **null**);  
58.     \}  
59.   
60.     /\*\* 
61.      \* 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
62.      \*  
63.      \* @param pContext 
64.      \*            上下文 
65.      \* @param styleID 
66.      \*            对话框样式 
67.      \*            ProgressDialog.STYLE\_HORIZONTAL|ProgressDialog.STYLE\_SPINNER 
68.      \* @param pTitle 
69.      \*            标题 
70.      \* @param pMessage 
71.      \*            内容 
72.      \* @param pCallEarliest 
73.      \*            运行于主线程，最先执行此方法. 
74.      \* @param progressCallable 
75.      \*            运行于异步线程,用于传递对话框进度. 
76.      \* @param pCallback 
77.      \*            运行于主线程,最后执行此方法. 
78.      \*/  
79.     **public** **static** <T> **void** doProgressAsync(**final** Context pContext,  
80.             **final** **int** styleID, **final** String pTitle, **final** String pMessage,  
81.             **final** CallEarliest<T> pCallEarliest,  
82.             **final** ProgressCallable<T> progressCallable,  
83.             **final** Callback<T> pCallback) \{  
84.   
85.         **new** AsyncTask<Void, Void, T>() \{  
86.   
87.             **private** ProgressDialog mProgressDialog;  
88.   
89.             /\*\* 
90.              \* 首先运行此方法,运行于主线程 
91.              \*/  
92.             @Override  
93.             **protected** **void** onPreExecute() \{  
94.                 **super**.onPreExecute();  
95.   
96.                 mProgressDialog = **new** ProgressDialog(pContext);  
97.                 mProgressDialog.setProgressStyle(styleID);  
98.                 mProgressDialog.setTitle(pTitle);  
99.                 mProgressDialog.setMessage(pMessage);  
100.                 mProgressDialog.setIndeterminate(**false**);  
101.                 mProgressDialog.show();  
102.                 **try** \{  
103.                     pCallEarliest.onCallEarliest();  
104.                 \} **catch** (Exception e) \{  
105.                     Log.e("error", e.toString());  
106.                 \}  
107.             \}  
108.   
109.             /\*\* 
110.              \* 第二步执行这个方法，这个方法运行在异步线程中 
111.              \*/  
112.             @Override  
113.             **protected** T doInBackground(Void... params) \{  
114.                 **try** \{  
115.                     **return** progressCallable.call(**new** IProgressListener() \{  
116.   
117.                         @Override  
118.                         **public** **void** onProgressChanged(**int** pProgress) \{  
119.                             // TODO Auto-generated method stub  
120.                             onProgressUpdate(pProgress);  
121.                         \}  
122.                     \});  
123.                 \} **catch** (Exception e) \{  
124.                     Log.e("error", e.toString());  
125.                 \}  
126.   
127.                 **return** **null**;  
128.             \}  
129.   
130.             /\*\* 
131.              \* 更新进度框 
132.              \*/  
133.             **protected** **void** onProgressUpdate(**final** Integer... values) \{  
134.                 mProgressDialog.setProgress(values\[0\]);  
135.             \};  
136.   
137.             /\*\* 
138.              \* 第三步执行这个方法，运行于主线程 
139.              \*/  
140.             **protected** **void** onPostExecute(T result) \{  
141.                 **if** (mProgressDialog != **null**)  
142.                     mProgressDialog.dismiss();  
143.                 pCallback.onCallback(result);  
144.   
145.             \}  
146.   
147.         \}.execute((Void\[\]) **null**);  
148.   
149.     \}  
150.   
151.     /\*\* 
152.      \* 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
153.      \*  
154.      \* @param pContext 
155.      \*            上下文 
156.      \* @param styleID 
157.      \*            对话框样式 
158.      \*            ProgressDialog.STYLE\_HORIZONTAL|ProgressDialog.STYLE\_SPINNER 
159.      \* @param pTitle 
160.      \*            标题,资源id 
161.      \* @param pMessage 
162.      \*            内容,资源id 
163.      \* @param pCallEarliest 
164.      \*            运行于主线程，最先执行此方法. 
165.      \* @param progressCallable 
166.      \*            运行于异步线程,用于传递对话框进度. 
167.      \* @param pCallback 
168.      \*            运行于主线程,最后执行此方法. 
169.      \*/  
170.     **public** **static** <T> **void** doProgressAsync(**final** Context pContext,  
171.             **final** **int** styleID, **final** **int** pTitleResId, **final** **int** pMessageResId,  
172.             **final** CallEarliest<T> pCallEarliest,  
173.             **final** ProgressCallable<T> progressCallable,  
174.             **final** Callback<T> pCallback) \{  
175.         AsyncTaskUtils.doProgressAsync(pContext, styleID,  
176.                 pContext.getString(pTitleResId),  
177.                 pContext.getString(pMessageResId), pCallEarliest,  
178.                 progressCallable, pCallback);  
179.     \}  
180.   
181. \}

**BaseActivity:**

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  /\*\* 
2.   \* 公用Activity,用于存放与业务无关的公用方法 
3.   \*  
4.   \* @ClassName: BaseActivity 
5.   \* @author 姜涛 
6.   \* @version 1.0 2011-12-11 下午7:03:18 
7.   \*/  
8.  **public** **abstract** **class** BaseActivity **extends** Activity \{  
9.    
10.     /\*\* 
11.      \* 封装的asynctask方法，此方法没有进度框. 
12.      \*  
13.      \* @param pCallEarliest 运行于主线程，最先执行此方法. 
14.      \* @param mCallable 运行于异步线程,第二执行此方法. 
15.      \* @param mCallback 运行于主线程,最后执行此方法. 
16.      \*/  
17.     **public** <T> **void** doAsync(**final** CallEarliest<T> pCallEarliest,  
18.             **final** Callable<T> mCallable, **final** Callback<T> mCallback) \{  
19.         AsyncTaskUtils.doAsync(pCallEarliest, mCallable, mCallback);  
20.     \}  
21.   
22.     /\*\* 
23.      \* 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
24.      \* @param pContext  上下文 
25.      \* @param styleID   对话框样式 ProgressDialog.STYLE\_HORIZONTAL|ProgressDialog.STYLE\_SPINNER 
26.      \* @param pTitle    标题 
27.      \* @param pMessage  内容 
28.      \* @param pCallEarliest  运行于主线程，最先执行此方法. 
29.      \* @param progressCallable 运行于异步线程,用于传递对话框进度. 
30.      \* @param pCallback  运行于主线程,最后执行此方法. 
31.      \*/  
32.     **public** <T> **void** doProgressAsync(**final** Context pContext, **final** **int** styleID,  
33.             **final** String pTitleResID, **final** String pMessageResID,  
34.             **final** CallEarliest<T> pCallEarliest, **final** ProgressCallable<T> pCallable,  
35.             **final** Callback<T> pCallback) \{  
36.   
37.         AsyncTaskUtils.doProgressAsync(pContext, styleID, pTitleResID,  
38.                 pMessageResID, pCallEarliest, pCallable, pCallback);  
39.     \}  
40.       
41.       
42.     /\*\* 
43.      \* 封装的asynctask方法，此方法拥有进度对话框，并支持定义样式. 
44.      \* @param pContext  上下文 
45.      \* @param styleID   对话框样式 ProgressDialog.STYLE\_HORIZONTAL|ProgressDialog.STYLE\_SPINNER 
46.      \* @param pTitle    标题,资源id 
47.      \* @param pMessage  内容,资源id 
48.      \* @param pCallEarliest  运行于主线程，最先执行此方法. 
49.      \* @param progressCallable 运行于异步线程,用于传递对话框进度. 
50.      \* @param pCallback  运行于主线程,最后执行此方法. 
51.      \*/  
52.     **public** <T> **void** doProgressAsync(**final** Context pContext, **final** **int** styleID,  
53.             **final** **int** pTitleResID, **final** **int** pMessageResID,  
54.             **final** CallEarliest<T> pCallEarliest, **final** ProgressCallable<T> pCallable,  
55.             **final** Callback<T> pCallback) \{  
56.   
57.         AsyncTaskUtils.doProgressAsync(pContext, styleID, pTitleResID,  
58.                 pMessageResID, pCallEarliest, pCallable, pCallback);  
59.     \}  
60.   
61.       
62. \}

**SimpleAsyncTaskActivity:**

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  **public** **class** SimpleAsyncTaskActivity **extends** BaseActivity \{  
2.      /\*\* Called when the activity is first created. \*/  
3.      @Override  
4.      **public** **void** onCreate(Bundle savedInstanceState) \{  
5.          **super**.onCreate(savedInstanceState);  
6.    
7.          **this**.doProgressAsync(**this**, ProgressDialog.STYLE\_HORIZONTAL,  
8.                  R.string.app\_name, R.string.app\_name, **new** CallEarliest<Void>() \{  
9.    
10.                     @Override  
11.                     **public** **void** onCallEarliest() **throws** Exception \{  
12.                         // TODO Auto-generated method stub  
13.   
14.                     \}  
15.   
16.                 \}, **new** ProgressCallable<Void>() \{  
17.   
18.                     @Override  
19.                     **public** Void call(IProgressListener pProgressListener)  
20.                             **throws** Exception \{  
21.                         // TODO Auto-generated method stub  
22.                         **for** (**int** i = 0; i < 100; i++) \{  
23.                             Thread.sleep(200);  
24.                             pProgressListener.onProgressChanged(i);  
25.                         \}  
26.                         **return** **null**;  
27.                     \}  
28.   
29.                 \}, **new** Callback<Void>() \{  
30.   
31.                     @Override  
32.                     **public** **void** onCallback(Void pCallbackValue) \{  
33.                         // TODO Auto-generated method stub  
34.   
35.                     \}  
36.                 \});  
37.     \}  
38. \}

**效果图:**

![1efe5d22-0b27-349e-b4f7-d9da0b6987cd.gif][]

**示例可参见附件.**

*  [SimpleAsyncTask.zip][] (58.5 KB)

[icon_star.png]: http://lewisliu.iteye.com/images/icon_star.png
[icon_star.png 1]: /images/20220731/69148c93753045f6af9742d2441f872a.png
[1efe5d22-0b27-349e-b4f7-d9da0b6987cd.gif]: /images/20220731/78b848a7ef4a4985ad6411432088f8eb.png
[SimpleAsyncTask.zip]: http://dl.iteye.com/topics/download/a074d6c2-5ff8-36dc-99c7-f255f2b3f6b2

发表评论取消回复

表情：

评论列表（有 0 条评论，212人围观）

还没有评论，来说两句吧...

相关阅读

相关封装对数据库的操作

基础实现请参考：[https://blog.csdn.net/weixin\_42230348/article/details/103044584][https_blog.c

拼搏现实的明天。/ 2023年06月13日 11:23/ 0 赞/ 2 阅读

相关异步编程Ajax的详解，并对其进行封装整理

对于Ajax，肯定很多小伙伴都听过甚至用过了，那么没听过的也不用着急，本文会对Ajax进行讲解，其次，一定还有一些人只用过JQuery封装好了的Ajax却对原生的Ajax并不了

左手的ㄟ右手/ 2022年12月12日 01:55/ 0 赞/ 138 阅读

相关 Vue对axios进行封装简化请求操作

[原文][Link 1]：`https://www.blog.hiyj.cn/article/detail/96` 一、[源码链接][Link 2]:`https://gi

﹏ヽ暗。殇╰゛Y/ 2022年09月11日 12:09/ 0 赞/ 180 阅读

相关 AsyncTask异步任务类

先来一个效果 ![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2ljaHVhbnd3dw_s

「爱情、让人受尽委屈。」/ 2022年09月11日 01:16/ 0 赞/ 238 阅读

相关 Android 异步操作AsyncTask

既然AsyncTask如此之好，为什么还要用new Theard 和 Handler。容我先转载考虑一下。。 ===============================

系统管理员/ 2022年08月21日 03:30/ 0 赞/ 276 阅读

相关 Android万能适配器简化繁琐的开发

Android万能适配器简化繁琐的开发原文链接：[http://mp.weixin.qq.com/s?\_\_biz=MzA3MzE2MjgyMQ==&mid=4012

短命女/ 2022年08月20日 10:21/ 0 赞/ 257 阅读

相关 AsyncTask异步任务总结

在实际应用中经常会遇到比较耗时任务的处理，比如网络连接，数据库操作等情况时，如果这些操作都是放在主线程（UI线程）中，则会造成UI的假死现象。臭名昭著的ANR（程序无响应）使得

矫情吗；*/ 2022年08月19日 08:18/ 0 赞/ 262 阅读

相关对AsyncTask进行封装，简化繁琐的异步操作

对于android的异步操作，往往有二种方法给予我们选择。一：Thread+Handler 二: AsyncTask 对于

ゝ一世哀愁。/ 2022年08月04日 01:59/ 0 赞/ 213 阅读

相关 AsyncTask异步任务

![Center][] </pre></p><p></p><p><pre name="code" class="java">package cn.edu.jlnu.a

待我称王封你为后i/ 2022年07月16日 04:59/ 0 赞/ 280 阅读

相关 Android——AsyncTask（异步）简介

个人理解具体应用 AsyncTask分析简单使用复杂应用

骑猪看日落/ 2022年07月14日 08:07/ 0 赞/ 262 阅读