Android - 服务器json数据交互.
一,服务器端
服务器端使用的是Servlet,封装json对象使用的 'json-lib-2.2.2-jdk15.jar,ezmorph-1.0.4.jar,commons-logging-1.1.jar,commons-lang-2.4.jar,commons-collections-3.2.jar,commons-beanutils-1.7.0.jar' 6个jar包.可在 json封装的jar包 中下载,我也不懂最近什么情况,使用Firefox总是很难下载csdn资源,可以使用ie.
1.首先是使用一个Person进行原始数据的封装:
package spt.src;
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
2.然后是两个服务类PersonService和JsonService,分别提供Person对象和将Person对象转换为json格式的字符串的服务类.
package spt.service;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import spt.src.Person;
/**
* 该类用于产生Person对象的服务类.
*
* @author Administrator 2015-1-29
*/
public class PersonService {
public Person getAPerson() {
return new Person("莉莉", 21);
}
public List<Person> getListPersons() {
List<Person> persons = new ArrayList<Person>();
persons.add(new Person("李静", 23));
persons.add(new Person("lucy", 20));
persons.add(new Person("小气", 22));
return persons;
}
/**获取 id-Person对应的Map列表.
* @return
*/
public List<Map<String, Person>> getListMaps() {
List<Map<String, Person>> maps = new ArrayList<Map<String,Person>>();
Map<String, Person> map01 = new HashMap<String, Person>();
map01.put("a01", new Person("王静", 19));
map01.put("a02", new Person("json", 26));
Map<String, Person> map02 = new HashMap<String, Person>();
map01.put("b01", new Person("okay", 19));
map01.put("b02", new Person("小琴", 24));
maps.add(map01);
maps.add(map02);
return maps;
}
}
package spt.service;
import net.sf.json.JSONObject;
/**将对象映射为json格式数据的服务类.
* @author Administrator
*2015-1-29
*/
public class JsonService {
public String getJsonStr(String key, Object value) {
JSONObject jsonObject = new JSONObject();
jsonObject.put(key, value);
return jsonObject.toString();
}
}
3.HttpServlet的子类JsonServlet,用于响应客户端的Servlet的核心处理类.
package spt.servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import spt.service.JsonService;
import spt.service.PersonService;
@WebServlet("/JsonAction")
public class JsonServlet extends HttpServlet{
/**
*
*/
private static final long serialVersionUID = 1L;
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//get person data.
PersonService personService = new PersonService();
//change person as json.
JsonService jsonService = new JsonService();
String action = req.getParameter("action");
String json = null;
if("p".equalsIgnoreCase(action))
json = jsonService.getJsonStr("p", personService.getAPerson());
else if("plst".equalsIgnoreCase(action))
json = jsonService.getJsonStr("plst", personService.getListPersons());
else if("plstMap".equalsIgnoreCase(action))
json = jsonService.getJsonStr("plstMap", personService.getListMaps());
System.out.println(json);
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp); //Get的处理方式和POST的处理方式一样.
}
}
4.另外的一个类是处理不同响应的编码的统一类:
package spt.servlet.filter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
//filter all servlets.
@WebFilter("/*")
public class EncodingFilter implements Filter {
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest httpReq = (HttpServletRequest) servletRequest;
//由于HttpServletRequest.setCharacterEncoding()对get方式不起作用,所以要单独编码.
if ("GET".equals(httpReq.getMethod()))
filterChain.doFilter(new HttpServletRequestEncodingWrapper(httpReq), servletResponse);
else {
//use utf encoding for none-get request.
httpReq.setCharacterEncoding("utf-8");
filterChain.doFilter(httpReq, servletResponse);
}
}
public void init(FilterConfig filterConfig) throws ServletException {
}
/**inner class dealing for 'GET' method.
* @author Administrator
*2015-1-27
*/
private class HttpServletRequestEncodingWrapper extends HttpServletRequestWrapper {
public HttpServletRequestEncodingWrapper(HttpServletRequest request) {
super(request);
}
@Override
public String getParameter(String name) {
//encode with 'iso', and than decode with 'utf'.
String val = super.getRequest().getParameter(name);
if (null != val) {
try {
return new String(val.getBytes("iso8859-1"), "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
return super.getParameter(name);
}
}
public void destroy() {
}
}
到此,服务器端已经基本完成,启动服务器后,可在浏览器中输入不同请求参数的url获取不同的json字符串,例如
http://192.168.1.101:8080/ReceiveAndroid/JsonAction?action=Plst
可获得
{"plst":[{"age":23,"name":"李静"},{"age":20,"name":"lucy"},{"age":22,"name":"小气"}]}
接触json数据不是很多,不过很奇怪的是,为什么获得Map列表的时候,我在调试的时候,获得的Map的size()是2,但是在使用url为:
http://192.168.1.101:8080/ReceiveAndroid/JsonAction?action=plstMap
的时候,获取的json字符串为:
{"plstMap":[{"b01":{"age":19,"name":"okay"},"a01":{"age":19,"name":"王静"},"a02":{"age":26,"name":"json"},"b02":{"age":24,"name":"小琴"}},{}]}
末尾有一个成员为空的'{}'.
二,接下来写Android客户端
1.首先,记得加 Internet permission.
2.Activity代码:
package spt.http.activity;
import java.lang.ref.WeakReference;
import spt.http.get.activity.R;
import spt.http.post.PostSender;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
public class MainActivity extends Activity {
//view.
private EditText edt_param = null;
private Button btn_ok = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initView();
initListener();
}
/**
* 初始化View.
*/
private void initView() {
edt_param = (EditText)findViewById(R.id.edt_para);
btn_ok = (Button)findViewById(R.id.btn_ok);
//test:
edt_param.setText("plstMap");
}
/**使用静态内部类,解决'This Handler class should be static or leaks might occur',以免造成内存泄露.
* @author Administrator
*
*/
private static class StatusHandler extends Handler {
WeakReference<MainActivity> iMainActivity = null;
public StatusHandler(MainActivity mainActivity) {
iMainActivity = new WeakReference<MainActivity>(mainActivity);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case PostSender.SEND_SUCCESS:
//有iMainActivity.get()和iMainActivity.getClass().
Toast.makeText(iMainActivity.get(), "发送成功", Toast.LENGTH_SHORT).show();
break;
case PostSender.SEND_FAIL:
Toast.makeText(iMainActivity.get(), "发送失败", Toast.LENGTH_SHORT).show();
break;
default:
throw new RuntimeException("未知的发送结果!");
}
}
}
/**
* 处理发送是否成功的状态的Handler.
*/
private final Handler handler = new StatusHandler(this);
/**
* 初始化监听器.
*/
private void initListener() {
//点击按钮,往服务器端发送数据.
btn_ok.setOnClickListener(new Button.OnClickListener() {
@Override
public void onClick(View v) {
String name = edt_param.getText().toString();
if(name.isEmpty()) {
Toast.makeText(MainActivity.this, "参数不能为空", Toast.LENGTH_SHORT).show();
return;
}
new PostSender(handler).send(name);
}
});
}
}
3.使用Apache提供的HTTPClient进行POST请求的业务逻辑层类:
package spt.http.post;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.http.HttpResponse;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.json.JSONException;
import spt.json.JsonParser;
import spt.src.Person;
import android.os.Handler;
import android.util.Log;
/**
* 用户向服务器端发送数据的类(使用post)方法.
*
* @author Administrator
*
*/
public class PostSender {
// 连接服务器的url.
private static final String URL = "http://192.168.1.101:8080/ReceiveAndroid/JsonAction";
// 标识是否连接到服务器成功.
public static final int SEND_SUCCESS = 1;
public static final int SEND_FAIL = 0;
private Handler handler = null; //新线程关联的Handler,用于将是否发送成功的标识Message放到消息队列中.
public PostSender(Handler handler) {
this.handler = handler;
}
/**
* 往服务器发送数据.
*
* @param param
* @param pwd
*/
public void send(String param) {
// 这里params要传递到另外一个方法,加final为了防止被修改.
final Map<String, String> params = new HashMap<String, String>();
params.put("action", param);
// 启动新的线程连接服务器.
new Thread(new Runnable() {
@Override
public void run() {
// 请求连接.
try {
if (postSend(params, URL, "utf-8"))
handler.sendEmptyMessage(SEND_SUCCESS);
else
handler.sendEmptyMessage(SEND_FAIL);
} catch (MalformedURLException e) {
Log.d("sysout", "run:MalformedURLException" + e.getMessage());
} catch (IOException e) {
Log.d("sysout", "run:IOException" + e.getMessage());
}
}
}).start();
}
/**
* 发送post请求的方法.
*
* @param params
* 请求参数的键-值对.
* @param url
* @param encoding
* 使用指定编码对参数值进行编码.
* @return
* @throws MalformedURLException
* @throws IOException
*/
private boolean postSend(Map<String, String> params, String url,
String encoding) throws MalformedURLException, IOException {
// 封装请求参数的键值对.
List<BasicNameValuePair> pairs = new ArrayList<BasicNameValuePair>();
for (Entry<String, String> param : params.entrySet()) {
pairs.add(new BasicNameValuePair(param.getKey(), param.getValue()));
}
//封装请求参数的实体.
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(pairs, encoding);
//使用post请求.
HttpPost post = new HttpPost(url);
post.setEntity(entity);
//使用DefaultHttpClient指定请求,以获取响应信息.
DefaultHttpClient client = new DefaultHttpClient();
HttpResponse response = client.execute(post);
BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), "utf-8"));
String ln = null;
while((ln = reader.readLine()) != null) {
// Log.d("sysout", ln);
try {
List<Map<String, Person>> maps = JsonParser.getListPersonMap("plstMap", ln);
for (Map<String, Person> map : maps) {
for (Entry<String, Person> en : map.entrySet()) {
Person p = en.getValue();
Log.d("sysout", "k:" + en.getKey() + "->" + p.getName() + "," + p.getAge());
}
}
} catch (JSONException e) {
Log.d("sysout", "postSend::readLine:JSONException" + e.getMessage());
e.printStackTrace();
}
}
return response.getStatusLine().getStatusCode() == 200; // 等于200表示发送成功.
}
}
4.在客户端定义一个对象类,与服务器端的一致,用来封装json数据.
package spt.src;
/**用于将json数据转换的目标对象的类.
* @author Administrator
*
*/
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
5.解析json数据为目标类对象的辅助类:
package spt.json;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import spt.src.Person;
/**
* 解析从服务器端获取的json数据,并封装为对象.
*
* @author Administrator
*
*/
public class JsonParser {
public static Person getPerson(String key, String jsonStr)
throws JSONException {
JSONObject jObj = new JSONObject(jsonStr);
JSONObject personObj = jObj.getJSONObject(key);
return new Person(personObj.getString("name"), personObj.getInt("age"));
}
/**
* 根据json数据,返回对象列表.
*
* @param key
* @param jsonStr
* @return
* @throws JSONException
*/
public static List<Person> getPersonList(String key, String jsonStr)
throws JSONException {
JSONObject jsonObject = new JSONObject(jsonStr);
JSONArray jArr = jsonObject.getJSONArray(key);
List<Person> persons = new ArrayList<Person>(); // 存储返回对象.
JSONObject jObj = null;
for (int j = 0; j < jArr.length(); j++) {
jObj = jArr.getJSONObject(j);
persons.add(new Person(jObj.getString("name"), jObj.getInt("age")));
}
return persons;
}
/**
* 根据json数据,返回对象构成的键值对的列表.
*
* @param key
* @param jsonStr
* @return
* @throws JSONException
*/
public static List<Map<String, Person>> getListPersonMap(String key,
String jsonStr) throws JSONException {
JSONObject jsonObject = new JSONObject(jsonStr);
List<Map<String, Person>> personMaps = new ArrayList<Map<String, Person>>(); // 存储返回对象构成的键值对.
//Map<String, Person>构成的数组.
JSONArray jArr = jsonObject.getJSONArray(key);
JSONObject jObj = null;
for (int j = 0; j < jArr.length(); j++) {
jObj = jArr.getJSONObject(j);
//迭代每一个Map<String, Person>.
Map<String, Person> personMap = new HashMap<String, Person>();
@SuppressWarnings("unchecked")
Iterator<String> ks = jObj.keys();
JSONObject jPersonObj = null; //一个Person对象对应的json.
String k = null; //Person对象对应的键.
while(ks.hasNext()) {
k = ks.next();
jPersonObj = (JSONObject)jObj.get(k);
//将Person对象封装到Map中.
personMap.put(k, new Person(jPersonObj.getString("name"), jPersonObj.getInt("age")));
}
//将Map<String, Person>封装成数组.
personMaps.add(personMap);
}
return personMaps;
}
}
客户端可以运行,在这里偷懒一下,对于不同解析,如何遍历List<Person> 和显示Person单独对象,相对简单,所以就省略了.
json api: http://json-lib.sourceforge.net/apidocs/jdk15/