详解android与服务端交互的两种方式

做android开发的程序员必须知道android客户端应该如何与服务端进行交互，这里主要介绍的是使用json数据进行交互。服务端从数据库查出数据并以json字符串的格式或者map集合的格式返回到客户端，客户端进行解析并输出到手机屏幕上。

此处介绍两种方式：使用google原生的gson解析json数据，使用jsonobject解析json数据

一、使用google原生的gson解析json数据：

记得在客户端添加gson.jar。

核心代码：

服务端：

package com.mfc.ctrl;

import java.util.hashmap;
import java.util.list;
import java.util.map;

import javax.annotation.resource;
import javax.servlet.http.httpservletrequest;

import org.springframework.stereotype.controller;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.responsebody;

import com.mfc.dao.tbluserdao;
import com.mfc.entity.tbluser;

/**
 * 2017年7月6日06:26:40
 * 对用户操作的控制器类 
 * */
@controller
@requestmapping("tbluserctrl")
public class tbluserctrl {

  @resource(name="tbluserdao")
  tbluserdao tbluserdao;

  //添加用户
  @requestmapping("adduser")
  @responsebody
  public object adduser(httpservletrequest request){
    string uname=request.getparameter("uname");
    string upass=request.getparameter("upass");
    float money=float.parsefloat(request.getparameter("money"));
    system.out.println(uname+"==="+upass+"==="+money);
    tbluser tbluser=new tbluser();
    tbluser.setmoney(money);
    tbluser.setuname(uname);
    tbluser.setupass(upass);

    tbluserdao.adduser(tbluser);

    map<string, object> map=new hashmap<string, object>();
    map.put("success", "success");
    return map;
  }

  //查看所有用户
  @requestmapping("getalluser")
  @responsebody
  public object getalluser(){
    list<tbluser> list = tbluserdao.selectalluser();
    map<string, object> map=new hashmap<string, object>();
    map.put("list", list);
    return map;
  }

  //删除用户
  @requestmapping("deluser")
  @responsebody
  public object deluser(httpservletrequest request){
    int uid=integer.parseint(request.getparameter("uid"));
    tbluser tbluser=tbluserdao.getuserbyid(uid);
    tbluserdao.deluser(tbluser);
    map<string, object> map=new hashmap<string, object>();
    map.put("success", "success");
    return map;
  }

  //修改用户
  @requestmapping("updateuser")
  @responsebody
  public object updateuser(httpservletrequest request){
    int uid=integer.parseint(request.getparameter("uid"));
    string uname=request.getparameter("uname");
    string upass=request.getparameter("upass");
    float money=float.parsefloat(request.getparameter("money"));
    tbluser tbluser=new tbluser();
    tbluser.setmoney(money);
    tbluser.setuid(uid);
    tbluser.setuname(uname);
    tbluser.setupass(upass);
    tbluserdao.updateuser(tbluser);

    map<string, object> map=new hashmap<string, object>();
    map.put("success", "success");
    return map;
  }
}

客户端：

拼接url的类：

package com.mfc.urlutils;

import java.util.map;

/**
 * 2017年7月6日06:42:10
 * 一些url需要使用的公用数据及方法
 * */
public class somepublicdata {
  //公用path
  public static final string path="http://192.168.0.111:8080/myeclipseservice/tbluserctrl/";

  //拼接path
  public static string fullpath(string pathlast, map<string, string> map) {
    stringbuilder builder = new stringbuilder();
    string realpath = null;
    if(map!=null && !map.isempty()){
      //拼接url的参数部分
      for (map.entry<string, string> entrty : map.entryset()) {
        builder.append(entrty.getkey()).append("=");
        builder.append(entrty.getvalue()).append("&");
      }
      builder.deletecharat(builder.length()-1);
      //拼接最后完整的url
      realpath = somepublicdata.path+pathlast+"?"+builder;
      return realpath;
    }

    return somepublicdata.path+pathlast;
  }
}

访问服务器的类：

package com.mfc.urlutils;

import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstreamreader;

import org.apache.http.httpentity;
import org.apache.http.httpresponse;
import org.apache.http.client.clientprotocolexception;
import org.apache.http.client.httpclient;
import org.apache.http.client.methods.httpget;
import org.apache.http.impl.client.defaulthttpclient;
import org.apache.http.params.httpconnectionparams;
import org.apache.http.params.httpparams;


/**
 * 2017年7月6日06:55:26
 * 将客户端数据传送到服务器，并接受服务器返回的数据
 * */
public class senddatetoserver {

  public static string sendtoserver(string path){
    stringbuilder builder=new stringbuilder();
    try {
      httpclient client=new defaulthttpclient();
      if(path != null && path.length() > 0){
        if(client != null){
          httpparams httpparams=client.getparams();
          if(httpparams != null){
            httpconnectionparams.setconnectiontimeout(httpparams, 60000);
            httpconnectionparams.setsotimeout(httpparams, 60000);
            httpget get=new httpget(path);
            if(get != null){
               httpresponse httpresponse=client.execute(get);
               if(httpresponse != null){
                 httpentity entity=httpresponse.getentity();
                 if(entity != null){
                   bufferedreader bufferedreader = new bufferedreader(new inputstreamreader(entity.getcontent()));
                   string line = null;
                   while((line = bufferedreader.readline()) != null){
                     builder.append(string.format("%s\n", line));
                   }
                   bufferedreader.close();
                 }
               }
            }
          }
        }
      }
    } catch (clientprotocolexception e) {
      e.printstacktrace();
    } catch (ioexception e) {
      e.printstacktrace();
    }
    return builder.tostring();
  } 
}

解析json数据的类：

package com.mfc.jsonutils;

import java.util.arraylist;
import java.util.list;

import org.json.jsonobject;

import com.google.gson.gson;
import com.google.gson.jsonarray;
import com.google.gson.jsonelement;
import com.google.gson.jsonparser;
import com.mfc.entity.tbluser;

/**
 * 2017年7月6日07:15:32
 * 解析json数据的类
 * */
public class getjsontoentity {

  //解析单个数据
  public static tbluser gettbluser(string jsonstring){
    gson gson = new gson();
    tbluser tbluser = gson.fromjson(jsonstring, tbluser.class);
    return tbluser;
  }

  //解析list集合
  public static list<tbluser> gettbluserlist(string gsonstring) {
    list<tbluser> listusers=gsonutil.parsejsonarraywithgson(gsonstring, tbluser.class);

    return listusers;
  }

}
/**
 * 2017年7月6日15:45:43
 * 封装的json解析工具类，提供泛型参数
 * */
class gsonutil{
  //将json数据解析成相应的映射对象
  public static <t> t parsejsonwithgson(string jsondata,class<t> type){
    gson gson=new gson();
    t result = gson.fromjson(jsondata, type);
    return result;
  }

  //将json数组解析成相应的映射对象列表
  public static <t> list<t> parsejsonarraywithgson(string jsondata,class<t> type){
    list<t> result = new arraylist<t>(); 
    try { 
      gson gson = new gson(); 
      jsonobject jsonobject=new jsonobject(jsondata);
      string string=jsonobject.getstring("list");
      jsonarray arry = new jsonparser().parse(string).getasjsonarray(); 
      for (jsonelement jsonelement : arry) { 
        result.add(gson.fromjson(jsonelement, type)); 
      } 
    } catch (exception e) { 
      e.printstacktrace(); 
    } 
    return result;
  }
}

调用这些方法的activity以及实体类省略。

二、使用jsonobject解析json数据

注意：服务端要添加json的jar包。

客户端解析json数据的代码：

 package com.mfc.jsonutils;

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 com.mfc.entity.task;


/**
 * 2017年6月25日21:34:44
 * 解析json的工具类
 * 这里面所有方法的key，都是json一层数据的键，注意传数据时调用本类方法的时候给的key值
 * */
public class parsejson {

  //解析单条数据
  public static task gettask(string key,string json){
    task task=new task();
    try {
      jsonobject jsonobject=new jsonobject(json);
      jsonobject taskobject=jsonobject.getjsonobject(key);
      task.settid(taskobject.getint("uid"));
      task.setcontent(taskobject.getstring("content"));
      task.setissuccess(taskobject.getint("issuccess"));
      task.settasktime(taskobject.getstring("tasktime"));
      task.settitle(taskobject.getstring("title"));
      task.setuid(taskobject.getint("uid"));
    } catch (jsonexception e) {
      e.printstacktrace();
    }
    return task;
  }

  //解析list集合
  public static list<task> getlisttask(string key,string jsonstring){
    list<task> list=new arraylist<task>();
    try {
      jsonobject jsonobject=new jsonobject(jsonstring);
      //解析json数组
      jsonarray array=jsonobject.getjsonarray(key);
      for (int i = 0; i < array.length(); i++) {
        jsonobject jsonobject2=array.getjsonobject(i);
        task task=new task();
        task.settid(jsonobject2.getint("uid"));
        task.setcontent(jsonobject2.getstring("content"));
        task.setissuccess(jsonobject2.getint("issuccess"));
        task.settasktime(jsonobject2.getstring("tasktime"));
        task.settitle(jsonobject2.getstring("title"));
        task.setuid(jsonobject2.getint("uid"));
        list.add(task);
      }
    } catch (jsonexception e) {
      e.printstacktrace();
    }
    return list;
  }

  /** 
   * 获取string数组数据 
   * @param key 
   * @param jsonstring 
   * @return 
   */ 
  public static list<string> getlist(string key,string jsonstring){ 
    list<string> list = new arraylist<string>(); 
    try { 
      jsonobject jsonobject = new jsonobject(jsonstring); 
      jsonarray jsonarray = jsonobject.getjsonarray(key); 
      for(int i=0;i<jsonarray.length();i++){ 
        string msg = jsonarray.getstring(i); 
        list.add(msg); 
      } 
    } catch (jsonexception e) { 
      e.printstacktrace(); 
    } 
    return list; 
  } 
  /** 
   * 获取对象的map集合数据 
   * @param key 
   * @param jsonstring 
   * @return 
   */ 
  public static list<map<string,object>> getlistmap(string key,string jsonstring){ 
    list<map<string,object>> list = new arraylist<map<string,object>>(); 
    try { 
      jsonobject jsonobject = new jsonobject(jsonstring); 
      jsonarray jsonarray = jsonobject.getjsonarray(key); 
      for(int i=0;i<jsonarray.length();i++){ 
        jsonobject jsonobject2 = jsonarray.getjsonobject(i); 
        map<string,object> map = new hashmap<string, object>(); 
        iterator<string> iterator = jsonobject2.keys(); 
        while(iterator.hasnext()){ 
          string json_key = iterator.next(); 
          object json_value = jsonobject2.get(json_key); 
          if(json_value==null){ 
            json_value = ""; 
          } 
          map.put(json_key, json_value); 
        } 
        list.add(map); 
      } 
    } catch (jsonexception e) { 
      // todo auto-generated catch block 
      e.printstacktrace(); 
    } 

    return list; 
  } 

}

客户端接收服务端的数据方法：

package com.mfc.urlutils;

import java.io.bytearrayoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.net.httpurlconnection;
import java.net.malformedurlexception;
import java.net.url;

import org.apache.http.entity.stringentity;

import android.util.log;

public class httputils {
  static string tag="httputils";

  /**
   * 从服务器获取json数据
   * */
  public static string getjsoncontent(string path){
    string jsonstring="";
    try {
      url url=new url(path);
      httpurlconnection connection=(httpurlconnection) url.openconnection();
      connection.setconnecttimeout(3000);
      connection.setrequestmethod("get");
      connection.setdoinput(true);
      int code=connection.getresponsecode();
      if(code==200){
        inputstream inputstream=connection.getinputstream();
        bytearrayoutputstream outputstream=new bytearrayoutputstream();
        int len=0;
        byte[] data=new byte[1024];
        while ((len=inputstream.read(data))!=-1) {
          outputstream.write(data, 0, len);
        }
        jsonstring=new string(outputstream.tobytearray());
        log.i(tag, jsonstring);
      }
    } catch (malformedurlexception e) {
      e.printstacktrace();
    } catch (ioexception e) {
      e.printstacktrace();
    }
    return jsonstring;
  }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。