安卓访问webAPI，并取回数据

前言

　　安卓自从4.0以后，所有的网络访问都需要异步进程操作。其自带的异步类有AsyncTask，Handler，以及可以声明Thread等等。涉及到多进程，必须要提到一个问题，线程与线程之间不能直接进行数据的交流，UI线程的数据是受到保护的，不能执行在UI线程上的操作都需要借助其他手段进行数据的传输，本文用的是Handler的sendMessage的方式。

正文

　　本文所用涉及Hander和Thread，首先介绍一下Hander。

　　Handler， 它直接继承自Object，一个Handler允许发送和处理Message或者Runnable对象，并且会关联到主线程的MessageQueue 中。每个Handler具有一个单独的线程，并且关联到一个消息队列的线程，就是说一个Handler有一个固有的消息队列。当实例化一个Handler 的时候，它就承载在一个线程和消息队列的线程，这个Handler可以把Message或Runnable压入到消息队列，并且从消息队列中取出 Message或Runnable，进而操作它们。

　　Handler主要有两个作用：

• 在工作线程中发送消息。
• 在UI线程中获取、处理消息。

　　上面介绍到Handler可以把一个Message对象或者Runnable对象压入到消息队列中，进而在UI线程中获取Message或者执行Runnable对象，所以Handler把压入消息队列有两大体系，Post和sendMessage：

• Post：Post允许把一个Runnable对象入队到消息队列中。它的方法有：post(Runnable)、postAtTime(Runnable,long)、postDelayed(Runnable,long)。
• sendMessage：sendMessage允许把一个包含消息数据的Message对象压入到消息队列中。它的方法 有：sendEmptyMessage(int)、sendMessage(Message)、 sendMessageAtTime(Message,long)、sendMessageDelayed(Message,long)。

　　从上面的各种方法可以看出，不管是post还是sendMessage都具有多种方法，它们可以设定Runnable对象和Message对象被入队到消息队列中，是立即执行还是延迟执行。

　　

Post

　　对于Handler的Post方式来说，它会传递一个Runnable对象到消息队列中，在这个Runnable对象中，重写run()方法。一般在这个run()方法中写入需要在UI线程上的操作。

　　在Handler中，关于Post方式的方法有：

• boolean post(Runnable r)：把一个Runnable入队到消息队列中，UI线程从消息队列中取出这个对象后，立即执行。
• boolean postAtTime(Runnable r,long uptimeMillis)：把一个Runnable入队到消息队列中，UI线程从消息队列中取出这个对象后，在特定的时间执行。
• boolean postDelayed(Runnable r,long delayMillis)：把一个Runnable入队到消息队列中，UI线程从消息队列中取出这个对象后，延迟delayMills秒执行
• void removeCallbacks(Runnable r)：从消息队列中移除一个Runnable对象。

　　下面通过一个Demo，讲解如何通过Handler的post方式在新启动的线程中修改UI组件的属性：

package com.bgxt.datatimepickerdemo;
 
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
 
public class HandlerPostActivity1 extends Activity {
    private Button btnMes1,btnMes2;
    private TextView tvMessage;
    // 声明一个Handler对象
    private static Handler handler=new Handler();
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.message_activity);        
 
        btnMes1=(Button)findViewById(R.id.btnMes1);
        btnMes2=(Button)findViewById(R.id.btnMes2);
        tvMessage=(TextView)findViewById(R.id.tvMessage);
        btnMes1.setOnClickListener(new View.OnClickListener() {
 
            @Override
            public void onClick(View v) {
                // 新启动一个子线程
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        // tvMessage.setText("...");
                        // 以上操作会报错，无法再子线程中访问UI组件，UI组件的属性必须在UI线程中访问
                        // 使用post方式修改UI组件tvMessage的Text属性
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                tvMessage.setText("使用Handler.post在工作线程中发送一段执行到消息队列中，在主线程中执行。");
                            }
                        });
                    }
                }).start();
            }
        });
 
        btnMes2.setOnClickListener(new View.OnClickListener() {
 
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        // 使用postDelayed方式修改UI组件tvMessage的Text属性值
                        // 并且延迟3S执行
                        handler.postDelayed(new Runnable() {
 
                            @Override
                            public void run() {
                                tvMessage.setText("使用Handler.postDelayed在工作线程中发送一段执行到消息队列中，在主线程中延迟3S执行。");    
 
                            }
                        }, 3000);
                    }
                }).start();
 
            }
        });
    }
}

效果展示：

　　有一点值得注意的是，对于Post方式而言，它其中Runnable对象的run()方法的代码，均执行在UI线程上，所以对于这段代码而言， 不能执行在UI线程上的操作，一样无法使用post方式执行。

Message

　　Handler如果使用sendMessage的方式把消息入队到消息队列中，需要传递一个Message对象，而在Handler中，需要重 写handleMessage()方法，用于获取工作线程传递过来的消息，此方法运行在UI线程上。下面先介绍一下Message。

　　Message是一个final类，所以不可被继承。Message封装了线程中传递的消息，如果对于一般的数据，Message提供了getData()和setData()方法来获取与设置数据，其中操作的数据是一个Bundle对 象，这个Bundle对象提供一系列的getXxx()和setXxx()方法用于传递基本数据类型的键值对，对于基本数据类型，使用起来很简单，这里不 再详细讲解。而对于复杂的数据类型，如一个对象的传递就要相对复杂一些。在Bundle中提供了两个方法，专门用来传递对象的，但是这两个方法也有相应的 限制，需要实现特定的接口，当然，一些Android自带的类，其实已经实现了这两个接口中的某一个，可以直接使用。方法如下：

• putParcelable(String key,Parcelable value)：需要传递的对象类实现Parcelable接口。
• pubSerializable(String key,Serializable value)：需要传递的对象类实现Serializable接口。

　　还有另外一种方式在Message中传递对象，那就是使用Message自带的obj属性传值，它是一个Object类型，所以可以传递任意类型的对象，Message自带的有如下几个属性：

• int arg1：参数一，用于传递不复杂的数据，复杂数据使用setData()传递。
• int arg2：参数二，用于传递不复杂的数据，复杂数据使用setData()传递。
• Object obj：传递一个任意的对象。
• int what：定义的消息码，一般用于设定消息的标志。

　　对于Message对象，一般并不推荐直接使用它的构造方法得到，而是建议通过使用Message.obtain()这个静态的方法或者 Handler.obtainMessage()获取。Message.obtain()会从消息池中获取一个Message对象，如果消息池中是空的， 才会使用构造方法实例化一个新Message，这样有利于消息资源的利用。并不需要担心消息池中的消息过多，它是有上限的，上限为10个。 Handler.obtainMessage()具有多个重载方法，如果查看源码，会发现其实Handler.obtainMessage()在内部也是 调用的Message.obtain()。　　

　　既然Message是在线程间传递消息，那么先以一个Demo讲解一下Message的使用，还是常规的从互联网上接受WEBAPI返回的数据，下载后使用listview控件展示：

package com.example.myrixin;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
 
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Intent;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;
 
public class MainActivity extends Activity implements OnItemClickListener, OnScrollListener {
	public ListView listView;
	private static int IS_FINISH = 1;
	private ProgressDialog dialog;
	private static String url="http://10.185.210.173:8008/api/products";
	private ArrayAdapter<List<Map<String, String>>>arr_adapter;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        //实例化listView
        listView=(ListView) findViewById(R.id.sjlb);
 
        dialog = new ProgressDialog(this);
        dialog.setTitle("提示信息");
        dialog.setMessage("正在下载，请稍后...");
        dialog.setCancelable(false);
 
        new Thread(new MyThread()).start();
		dialog.show();
 
//		//适配器
//		arr_adapter=new ArrayAdapter(null, 0, list);
//		//加入listview
//		listView.setAdapter(arr_adapter);
		listView.setOnItemClickListener(this);//单个条目点击的监听器
        listView.setOnScrollListener(this);//滚动变化的监听器
 
    }
 
	private Handler handler = new Handler() {
		Map<String, String> map = null;
		List<Map<String, String>> list = new ArrayList<Map<String, String>>();
 
		// 在Handler中获取消息，重写handleMessage()方法
		@Override
		public void handleMessage(Message msg) {
			// 判断消息码是否为1
			if (msg.what == IS_FINISH) {
				//text.setText(msg.toString);
				list = jx(msg.toString());
//				try {
//					//截取API返回的数据   Message传过来的数据加了首尾信息文
//					int begin=msg.toString().indexOf("[");
//					int end=msg.toString().indexOf("]");
//					String request=msg.toString().substring(begin, end+1);
//
//					JSONArray jsonArray = new JSONArray(request);
//					for (int i = 0; i < jsonArray.length(); i++) {
//						JSONObject item = jsonArray.getJSONObject(i); // 每条记录又由几个Object对象组成
//						int id = item.getInt("Id"); // 获取对象对应的值{"Id":1,"Name":"Tomato Soup","Category":"Groceries","Price":1.0}
//						String name = item.getString("Name");
//						String categroy=item.getString("Category");
//						String price = item.getString("Price");
//
//						map = new HashMap<String, String>(); // 存放到MAP里面
//						map.put("id", id + "");
//						map.put("name", name);
//						map.put("Category", categroy);
//						map.put("Price", price);
//						list.add(map);
//					}
//					for (Map<String, String> list2 : list) {
//						String id = list2.get("id");
//						String name = list2.get("name");
//						Log.i("info", "id:" + id + " | name:" + name);
//					}
//				} catch (JSONException e) {
//					// TODO Auto-generated catch block
//					e.printStackTrace();
//				}
				//适配器
				arr_adapter=new ArrayAdapter(MainActivity.this, android.R.layout.simple_expandable_list_item_1, list);
				//加入listview
				listView.setAdapter(arr_adapter);
				dialog.dismiss();
			}
		}
	};
 
	public class MyThread implements Runnable {
 
		@Override
		public void run() {
			HttpClient httpClient = new DefaultHttpClient();
			HttpGet httpGet = new HttpGet(url);
			HttpResponse httpResponse = null;
			try {
				httpResponse = httpClient.execute(httpGet);
				if (httpResponse.getStatusLine().getStatusCode() == 200) {
					 String temp = EntityUtils.toString(httpResponse.getEntity());
					// 获取一个Message对象，设置what为1
					Message msg = Message.obtain();
					msg.obj = temp;
					msg.what = IS_FINISH;
					// 发送这个消息到消息队列中
					handler.sendMessage(msg);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
 
	/*
	 * 解析json数据
	 */
	public List<Map<String, String>> jx(String msg){
		Map<String, String> map = null;
		List<Map<String, String>> list = new ArrayList<Map<String, String>>();
		try {
			//截取API返回的数据   Message传过来的数据加了首尾信息文
			int begin=msg.toString().indexOf("[");
			int end=msg.toString().indexOf("]");
			String request=msg.toString().substring(begin, end+1);
 
			JSONArray jsonArray = new JSONArray(request);
			for (int i = 0; i < jsonArray.length(); i++) {
				JSONObject item = jsonArray.getJSONObject(i); // 每条记录又由几个Object对象组成
				int id = item.getInt("Id"); // 获取对象对应的值{"Id":1,"Name":"Tomato Soup","Category":"Groceries","Price":1.0}
				String name = item.getString("Name");
				String categroy=item.getString("Category");
				String price = item.getString("Price");
 
				map = new HashMap<String, String>(); // 存放到MAP里面
				map.put("id", id + "");
				map.put("name", name);
				map.put("Category", categroy);
				map.put("Price", price);
				list.add(map);
			}
			for (Map<String, String> list2 : list) {
				String id = list2.get("id");
				String name = list2.get("name");
				Log.i("info", "id:" + id + " | name:" + name);
			}
		} catch (JSONException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return list;
	}
 
/*
 * 自定义菜单栏
 * @see android.app.Activity#onCreateOptionsMenu(android.view.Menu)
 */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }
 
}

xml中的内容

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >
 
    <ListView
        android:id="@+id/sjlb"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true" >
    </ListView>
 
</RelativeLayout>

AndroidManifest.xml给网络访问权限

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

运行效果图：

aaarticlea/png;base64,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" alt="" />aaarticlea/png;base64,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" alt="" />

　　Message.obtain()方法具有多个重载方法，大致可以分为为两类，一类是无需传递Handler对象，对于这类的方法，当填充好消 息后，需要调用Handler.sendMessage()方法来发送消息到消息队列中。第二类需要传递一个Handler对象，这类方法可以直接使用 Message.sendToTarget()方法发送消息到消息队列中，这是因为在Message对象中有一个私有的Handler类型的属性 Target，当时obtain方法传递进一个Handler对象的时候，会给Target属性赋值，当调用sendToTarget()方法的时候，实 际在它内部还是调用的Target.sendMessage()方法。

　　在Handler中，也定义了一些发送空消息的方法，如：sendEmptyMessage(int what)、sendEmptyMessageDelayed(int what,long delayMillis)，看似这些方法没有使用Message就可以发送一个消息，但是如果查看源码就会发现，其实内部也是从 Message.obtain()方法中获取一个Message对象，然后给属性赋值，最后使用sendMessage()发送消息到消息队列中。

　　Handler中，与Message发送消息相关的方法有：

• Message obtainMessage()：获取一个Message对象。
• boolean sendMessage()：发送一个Message对象到消息队列中，并在UI线程取到消息后，立即执行。
• boolean sendMessageDelayed()：发送一个Message对象到消息队列中，在UI线程取到消息后，延迟执行。
• boolean sendEmptyMessage(int what)：发送一个空的Message对象到队列中，并在UI线程取到消息后，立即执行。
• boolean sendEmptyMessageDelayed(int what,long delayMillis)：发送一个空Message对象到消息队列中，在UI线程取到消息后，延迟执行。
• void removeMessage()：从消息队列中移除一个未响应的消息。

对Message感兴趣的可以参考：http://www.cnblogs.com/shirley-1019/p/3557800.html

本文的很多知识都是参考的次博文，我只对自己需要的部分做了修改