Android Gson 操作

JSON序列化后的数据不带类名与名命空间，所以这两个服务端跟客户端可以不对应,需要保证字段对应即可

Asp.net MVC端

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace cn.fstudio.hessian.dto
{
    public class ResponseBase<T>
    {
        private int code;
        private string msg;
        private T model;

        public int Code
        {
            get { return code; }
            set { code = value; }
        }
        public string Msg
        {
            get { return msg; }
            set { msg = value; }
        }
        public T Model
        {
            get { return model; }
            set { model = value; }

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using cn.fstudio.hessian.dto;
using cn.fstudio.update.model;
using AA.DAO;
using System.Text;
using EmitMapper;
namespace AA.Web.Controllers
{
    public class SoftController : Controller
    {
        //
        // GET: /Soft/
        /// <summary>
        /// 获取列表
        /// </summary>
        /// <returns></returns>
        public ActionResult Index()
        {
            var response = new ResponseBase<List<SoftInfo>>();
            try
            {
                using (var ctx = DBCtx.GetCtx())
                {
                   response.Model= ObjectMapperManager.DefaultInstance.GetMapper<List<Base_Soft>,List<SoftInfo>>().Map(ctx.Base_Soft.ToList());
                }
                response.Code = ;

            }
            catch (Exception ex)
            {
                response.Code = -;
                response.Msg = ex.Message;
            }
            return Json(response,"text/json",Encoding.UTF8,JsonRequestBehavior.AllowGet );
        }

        public ActionResult GetApp(String id,String v)
        {
            using (var ctx = DBCtx.GetCtx())
            {
                int softId=int.Parse(id);
                var q = ctx.Base_SoftVersion.Where(ent => ent.SoftId == softId);
                if (!String.IsNullOrWhiteSpace(v))
                {
                    q = q.Where(ent => ent.VersionCode == v);
                }

                q = q.OrderByDescending(ent => ent.VersionCode).Take();

                var it= q.FirstOrDefault();

                if (it == null)
                {
                    throw new Exception("未找到该软件!");
                }
                var soft= ctx.Base_Soft.FirstOrDefault(ent => ent.SoftId == softId);

                return File(Server.MapPath(it.Path), "application/vnd.android", Url.Encode(string.Format("{0}_{1}.apk",soft.FileName,it.VersionCode)));

            }

        }
        public ActionResult AppVers(String id)
        {
            var response = new ResponseBase<List<SoftVersionInfo>>();
            try
            {
                using (var ctx = DBCtx.GetCtx())
                {
                    var list= ctx.ExecuteStoreQuery<SoftVersionInfo>("Select SoftId,RecId,VersionName,VersionCode,AddTime From Base_SoftVersion Where SoftId={0} order by versionCode desc",id).ToList();
                    response.Model = list;
                }
                response.Code = ;

            }
            catch (Exception ex)
            {
                response.Code = -;
                response.Msg = ex.Message;
            }
            return Json(response, "text/json", Encoding.UTF8, JsonRequestBehavior.AllowGet);
        }
        public ActionResult AppLastVer(String id)
        {
            var response = new ResponseBase<SoftVersionInfo>();
            try
            {
                using (var ctx = DBCtx.GetCtx())
                {
                    var it = ctx.ExecuteStoreQuery<SoftVersionInfo>("Select Top 1 SoftId,RecId,VersionName,VersionCode,AddTime From Base_SoftVersion Where SoftId={0} order by versionCode desc,RecId desc", id).FirstOrDefault();
                    response.Model = it;
                }
                response.Code = ;

            }
            catch (Exception ex)
            {
                response.Code = -;
                response.Msg = ex.Message;
            }
            return Json(response, "text/json", Encoding.UTF8, JsonRequestBehavior.AllowGet);
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace cn.fstudio.update.model
{
    public class SoftInfo
    {
        private int softId;
        private string softName;
        private string versionName;
        private string versionCode;
        private DateTime addTime;
        private DateTime lastTime;
        private string memo;
        private int recId;
        private String fileName;

        public String FileName
        {
            get { return fileName; }
            set { fileName = value; }
        }

        /// <summary>
        /// SoftId
        /// </summary>
        public int SoftId
        {
            get { return softId; }
            set { softId = value; }
        }
        /// <summary>
        /// SoftName
        /// </summary>
        public string SoftName
        {
            get { return softName; }
            set { softName = value; }
        }
        /// <summary>
        /// VersionName
        /// </summary>
        public string VersionName
        {
            get { return versionName; }
            set { versionName = value; }
        }
        /// <summary>
        /// VersionCode
        /// </summary>
        public string VersionCode
        {
            get { return versionCode; }
            set { versionCode = value; }
        }
        /// <summary>
        /// AddTime
        /// </summary>
        public DateTime AddTime
        {
            get { return addTime; }
            set { addTime = value; }
        }
        /// <summary>
        /// LastTime
        /// </summary>
        public DateTime LastTime
        {
            get { return lastTime; }
            set { lastTime = value; }
        }
        /// <summary>
        /// Memo
        /// </summary>
        public string Memo
        {
            get { return memo; }
            set { memo = value; }
        }
        /// <summary>
        /// RecId
        /// </summary>
        public int RecId
        {
            get { return recId; }
            set { recId = value; }
        }
    }
}

android端

package cn.fstudio.update;

import java.lang.reflect.Type;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;

public class GsonUtil {

    public static class DateDeserializer implements JsonDeserializer<Date> {

        @Override
        public Date deserialize(JsonElement json, Type typeOfT,
                JsonDeserializationContext context) throws JsonParseException {
            String JSONDateToMilliseconds = "/Date\\((.*?)\\)/";
            Pattern pattern = Pattern.compile(JSONDateToMilliseconds);
            String value = json.getAsJsonPrimitive().getAsString();
            Matcher matcher = pattern.matcher(value);
            String result = matcher.replaceAll("$1");

            return new Date(new Long(result));
        }
    }

    public static Gson getGson() {
        GsonBuilder gsonb = new GsonBuilder();
        DateDeserializer ds = new DateDeserializer();
        gsonb.registerTypeAdapter(Date.class, ds);
        gsonb.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE);
        Gson gson = gsonb.create();
        return gson;

    }
}

package cn.fstudio.util;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.client.utils.URIUtils;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

import android.R.string;
import android.util.Log;

public class HttpClientUtil {

    private  static  HttpContext httpContext;
    static {
        // 创建一个本地Cookie存储的实例
        CookieStore cookieStore = new BasicCookieStore();
        // 创建一个本地上下文信息
        httpContext = new BasicHttpContext();
        // 在本地上下问中绑定一个本地存储
        httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);

    }
    public static String get(String baseUrl,String path,List<NameValuePair> qparams){

        try {
            URI uri=new URI(baseUrl);
            return get(uri.getScheme(), uri.getHost(), uri.getPort(), path, qparams);
        } catch (URISyntaxException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }

    }
    public static String get(String scheme,String host,int port,String path, List<NameValuePair> qparams){
        URI uri=null;
        try {

            if(qparams==null)qparams=new ArrayList<NameValuePair>();
            uri = URIUtils.createURI(scheme, host, port, path, URLEncodedUtils.format(qparams, "UTF-8"), null);
            Log.d("Test", uri.toString());
            return get(uri.toString());
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }

    }
    public static String get(String url){

        try {

            // HttpGet连接对象
            HttpGet httpRequest = new HttpGet(url);
            // 取得HttpClient对象
            HttpClient httpClient = new DefaultHttpClient();
            // 请求HttpClient，取得HttpResponse
            HttpResponse httpResponse = httpClient.execute(httpRequest,httpContext);
//            for (org.apache.http.Header h : httpResponse.getAllHeaders()) {
//                Log.d("Test",h.getName());
//            }

            // 请求成功
            int statusCode=httpResponse.getStatusLine().getStatusCode();
            if ( statusCode == HttpStatus.SC_OK) {
                HttpEntity entity=httpResponse.getEntity();
                // 取得返回的字符串
                String strResult = EntityUtils.toString(entity);
                entity.consumeContent();
                ////httpClient.getConnectionManager().shutdown();
                return strResult;
            }
            throw new RuntimeException("网络请求执行错误,响应码:" +statusCode);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

package cn.fstudio.update;

import java.io.Serializable;
import java.util.Date;

public class SoftInfo implements Serializable {
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private int softId;
    private String softName;
    private String versionName;
    private String versionCode;
    private Date addTime;
    private Date lastTime;
    private String memo;
    private int recId;
    private String fileName;
    public int getSoftId() {
        return softId;
    }
    public void setSoftId(int softId) {
        this.softId = softId;
    }
    public String getSoftName() {
        return softName;
    }
    public void setSoftName(String softName) {
        this.softName = softName;
    }
    public String getVersionName() {
        return versionName;
    }
    public void setVersionName(String versionName) {
        this.versionName = versionName;
    }
    public String getVersionCode() {
        return versionCode;
    }
    public void setVersionCode(String versionCode) {
        this.versionCode = versionCode;
    }
    public Date getAddTime() {
        return addTime;
    }
    public void setAddTime(Date addTime) {
        this.addTime = addTime;
    }
    public Date getLastTime() {
        return lastTime;
    }
    public void setLastTime(Date lastTime) {
        this.lastTime = lastTime;
    }
    public String getMemo() {
        return memo;
    }
    public void setMemo(String memo) {
        this.memo = memo;
    }
    public int getRecId() {
        return recId;
    }
    public void setRecId(int recId) {
        this.recId = recId;
    }
    public String getFileName() {
        return fileName;
    }
    public void setFileName(String fileName) {
        this.fileName = fileName;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
}

package cn.fstudio.update;

import java.io.Serializable;

public class ResponseBase<T> implements Serializable{

    private static final long serialVersionUID = 1L;
    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public T getModel() {
        return model;
    }
    public void setModel(T model) {
        this.model = model;
    }
    private int code;
    private String msg;
    private T model;
}

package cn.fstudio.test;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import android.util.Log;
import cn.fstudio.update.GsonUtil;
import cn.fstudio.update.ResponseBase;
import cn.fstudio.update.SoftInfo;

import cn.fstudio.update.SoftVersionInfo;
import cn.fstudio.util.HttpClientUtil;
import junit.framework.TestCase;

public class UpdateTest extends TestCase {
    final String TAG = "Test";

    public void testHttpClient() {
        List<NameValuePair> qparams = new ArrayList<NameValuePair>();
        qparams.add(new BasicNameValuePair("id", ""));
        String json = HttpClientUtil.get("http", "122.226.151.4", ,
                "/soft/AppLastVer", qparams);

    Type type =  new TypeToken<ResponseBase<SoftVersionInfo>>(){}.getType();
    Gson gson=GsonUtil.getGson();
    ResponseBase<SoftVersionInfo> response=    gson.fromJson(json, type);

        Log.d(TAG, json);
    }

    public void testSoft() {

        String json = HttpClientUtil.get("http", "122.226.151.4", ,
                "/soft/", null);
        Gson gson=GsonUtil.getGson();

        Type type =  new TypeToken<ResponseBase<List<SoftInfo>>>(){}.getType();

        ResponseBase<List<SoftInfo>> response=    gson.fromJson(json, type);
        Log.d(TAG, json);
    }
    public void testAppVers() {
        List<NameValuePair> qparams = new ArrayList<NameValuePair>();
        qparams.add(new BasicNameValuePair("id", "22a"));
        String json = HttpClientUtil.get("http", "122.226.151.4", ,
                "/soft/appVers", qparams);
        Gson gson=GsonUtil.getGson();

        Type type =  new TypeToken<ResponseBase<List<SoftVersionInfo>>>(){}.getType();

        ResponseBase<List<SoftVersionInfo>> response=    gson.fromJson(json, type);
        Log.d(TAG, json);
    }
    public void testAppLastVer() {
        List<NameValuePair> qparams = new ArrayList<NameValuePair>();
        qparams.add(new BasicNameValuePair("id", ""));
        String json = HttpClientUtil.get("http://122.226.151.4:7086/",
                "/soft/appLastVer", qparams);
        Gson gson=GsonUtil.getGson();

        Type type =  new TypeToken<ResponseBase<SoftVersionInfo>>(){}.getType();

        ResponseBase<SoftVersionInfo> response=    gson.fromJson(json, type);
        Log.d(TAG, json);
    }
}