• Unity的弱联网Json数据传输


    注意事项:
    关于dictionary转json的工程中遇到一点问题:要手动添加双引号。
    关于json转dictionary:同样需要手动去掉双引号,否则添加到dictionary中的字符串会带有双引号。打log的时候字符串输出本身是没有双引号的。
     
    返回Dictionary数据,代码都很简单,json的处理,当然也可以用其他json插件Litjson等,直接上代码。
     
    调用代码:
      void Start () {
            Thread t = new Thread (Check);    // No need to explicitly use ThreadStart
            t.Start();
     
        }
        static string TestServer = "http://192.168.1.105:8080/cross";
        static void Check() {
            HttpClients httpClient = new HttpClients();
            Dictionary<string, string> data = new Dictionary<string, string>();
            if(result==null){
                result = new Dictionary<string, string>();
            }else{
                result.Clear();
            }
            data.Add("appName","cutit");
            data.Add("platform","android");
            data.Add("language","chinese");
            data.Add("channel","offical");
     
            ResultResponse resultResponse = httpClient.OpenPostUrl(TestServer,null,data);
            string resultString = resultResponse.GetContent().ToString();
            Dictionary<string, string>m = httpClient.JsonToDict(resultString);
            int resultCode = int.Parse(m["resultCode"]);
            if(resultCode ==0){
                string adState = "" + m["adState"];
                string isShowLogoText = "" + m["key1"];
                Debug.Log("steve:" + adState + ":" + isShowLogoText);
                if(adState == "OFF"){
                    
                }
     
                if(isShowLogoText == "ON"){
                }
     
            }
        } 
    以下是 HttpClient 和 ResultResponse
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using System.Text;
    using UnityEngine;
    using System.Text.RegularExpressions;
    
    
    namespace HttpClient
    {
     
        /// <summary>
        /// 通过Http协议访问Web
        /// </summary>
        public class HttpClients
        {
            #region Cookie集合
            /// <summary>
            /// Cookie集合
            /// </summary>
            private CookieContainer cookies;
            #endregion
     
            #region Http user-agent标头值
            /// <summary>
            /// Http user-agent标头值
            /// </summary>
            public string UserAgent { get; set; }
            #endregion
     
            #region HttpClient构造函数
            public HttpClients()
            {
                this.cookies = new CookieContainer();
            }
            #endregion 
     
            #region 获取HttpClient的Cookie集合
            /// <summary>
            /// 获取HttpClient的Cookie集合
            /// </summary>
            /// <returns></returns>
            public CookieContainer GetCookieContainer()
            {
                return this.cookies;
            }
            #endregion
     
            #region 设置HttpClient的Cookie集合
            /// <summary>
            /// 设置HttpClient的Cookie集合
            /// </summary>
            /// <param name="_cookie">Cookie集合对象</param>
            /// <returns>True设置成功 False设置失败</returns>
            public bool SetCookieContainer(CookieContainer _cookie)
            {
                if (_cookie != null)
                {
                    this.cookies = _cookie;
                    return true;
                }
                return false;
            }
            #endregion
     
            #region 以GET方式打开一个Http连接
            /// <summary>
            /// 以GET方式打开一个Http连接
            /// </summary>
            /// <param name="url">地址</param>
            /// <param name="headers">请求头</param>
            /// <returns></returns>
            public ResultResponse OpenGetUrl(string url, Dictionary<string, string> headers)
            {
                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                request.CookieContainer = this.cookies;
                request.Method = HttpClients.ConnectionType.GET;
                request.KeepAlive = true;
                if (this.UserAgent != null && this.UserAgent != "")
                {
                    request.UserAgent = this.UserAgent;
                }
                this.FillHeaders(request, headers);
                HttpWebResponse response = request.GetResponse() as HttpWebResponse;
                return new ResultResponse(response);
            }
            #endregion
     
            #region 以GET方式打开一个Http连接,302自定义处理行为
            /// <summary>
            /// 以GET方式打开一个Http连接,302自定义处理行为
            /// </summary>
            /// <param name="url">地址</param>
            /// <param name="headers">请求头</param>
            /// <param name="action">302跳转处理</param>
            /// <returns></returns>
            public ResultResponse OpenGetUrlRedirect(string url, Dictionary<string, string> headers,HttpClients.RedirectAction action)
            {
                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                request.CookieContainer = this.cookies;
                request.Method = HttpClients.ConnectionType.GET;
                request.KeepAlive = true;
                request.AllowAutoRedirect = false; //302不采用默认行为处理
                if (this.UserAgent != null && this.UserAgent != "")
                {
                    request.UserAgent = this.UserAgent;
                }
                this.FillHeaders(request, headers);
                HttpWebResponse response = request.GetResponse() as HttpWebResponse;
                ResultResponse result=new ResultResponse(response);
                if (response.StatusCode == HttpStatusCode.Found)
                {
                    bool ret = true;
                    if (action != null)
                    {
                        ret = action(result);
                    }
                    string locationurl = response.Headers["Location"];
                    if (ret == true)
                    {
                        return this.OpenGetUrlRedirect(locationurl, null, action);
                    }
                    return result;
                }
                return result;
            }
            #endregion
     
            #region Http 302跳转处理
            /// <summary>
            /// Http 302跳转处理
            /// </summary>
            /// <param name="result">响应对象</param>
            /// <returns>False 不继续跳转 True继续跳转</returns>
            public delegate bool RedirectAction(ResultResponse result);
            #endregion
     
            #region 将Http标头值添加到Request对象中
            /// <summary>
            /// 将Http标头值添加到Request对象中
            /// </summary>
            /// <param name="headers"></param>
            private void FillHeaders(HttpWebRequest request,Dictionary<string, string> headers)
            {
                if (headers != null && headers.Count > 0)
                {
                    Dictionary<string, string>.Enumerator em = headers.GetEnumerator();
                    while (em.MoveNext())
                    {
                        request.Headers.Add(em.Current.Key, em.Current.Value);
                    }
                }
            }
            #endregion
     
            #region 以POST方式打开一个Http连接
            /// <summary>
            /// 以POST方式打开一个Http连接
            /// </summary>
            /// <param name="url">地址</param>
            /// <param name="headers">请求头</param>
            /// <param name="data">发送的数据</param>
            /// <returns></returns>
            public ResultResponse OpenPostUrl(string url,Dictionary<string,string> headers,Dictionary<string,string> data)
            {
                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                request.CookieContainer = this.cookies;
                request.Method = HttpClients.ConnectionType.POST;
                request.KeepAlive = true;
                if (this.UserAgent != null && this.UserAgent != "")
                {
                    request.UserAgent = this.UserAgent;
                }
                this.FillHeaders(request, headers);
                byte[] buff = DictToBytes(data);
                request.GetRequestStream().Write(buff, 0, buff.Length);
                request.GetRequestStream().Close();
                HttpWebResponse response = request.GetResponse() as HttpWebResponse;
                return new ResultResponse(response);
            }
            #endregion
     
            #region 以POST方式打开一个Http连接,302自定义处理行为
            /// <summary>
            /// 以POST方式打开一个Http连接,302自定义处理行为
            /// </summary>
            /// <param name="url">地址</param>
            /// <param name="headers">请求头</param>
            /// <param name="data">发送的数据</param>
            /// <param name="action">302自定义处理</param>
            /// <returns></returns>
            public ResultResponse OpenPostUrlRedirect(string url, Dictionary<string, string> headers, Dictionary<string, string> data,HttpClients.RedirectAction action)
            {
                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                request.CookieContainer = this.cookies;
                request.Method = HttpClients.ConnectionType.POST;
                request.KeepAlive = true;
                request.AllowAutoRedirect = false;
                if (this.UserAgent != null && this.UserAgent != "")
                {
                    request.UserAgent = this.UserAgent;
                }
                this.FillHeaders(request, headers);
                byte[] buff = DictToBytes(data);
                request.GetRequestStream().Write(buff, 0, buff.Length);
                request.GetRequestStream().Close();
                HttpWebResponse response = request.GetResponse() as HttpWebResponse;
                ResultResponse result = new ResultResponse(response);
     
                if (response.StatusCode == HttpStatusCode.Found)
                {
                    bool ret = true;
                    if (action != null)
                    {
                        ret = action(result);
                    }
                    string locationurl = response.Headers["Location"];
                    return result;
                }
                return result;
            }
            #endregion
     
            #region 将字典的key和value拼接成http参数
            /// <summary>
            /// 将字典的key和value拼接成http参数
            /// </summary>
            /// <param name="dic">参数</param>
            /// <returns></returns>
            private byte[] DictToBytes(Dictionary<string, string> dic)
            {
                StringBuilder sb = null;
                if (dic != null)
                {
                    Dictionary<string,string>.Enumerator em= dic.GetEnumerator();
                    sb = new StringBuilder();
                    sb.Append("{");
                    while (em.MoveNext())
                    {
                        sb.Append(String.Format("{0}:{1};", '"'+ em.Current.Key + '"', '"' + em.Current.Value + '"'));
                    }
                    sb.Remove (sb.Length-1,1);
                    sb.Append("}");
                    return System.Text.Encoding.UTF8.GetBytes(sb.ToString());
                }
                return null;
            }
    
            public Dictionary<string, string> JsonToDict(string json)
            {
                StringBuilder sb = new StringBuilder(json);
                Dictionary<string, string> result = new Dictionary<string, string>();
                if (json != null && json != "") {
                    sb.Remove (0, 1);
                    sb.Remove (sb.Length - 1, 1);
                    string t = "" + sb;
                    string[] temp = Regex.Split (t, ",", RegexOptions.IgnoreCase);
    
                    for (int i = 0; i < temp.Length; i++) {    
                        temp[i] = Regex.Replace (temp [i], ""","", RegexOptions.IgnoreCase);
                        string[] splits = Regex.Split (temp [i],":", RegexOptions.IgnoreCase);
                        result.Add (splits [0].ToString(), splits [1].ToString());
                    }
    
                    return result;
                }
    
                return null;
            }
    
            #endregion
     
            #region HttpClient打开连接的方式
            /// <summary>
            /// HttpClient打开连接的方式
            /// </summary>
            public static class ConnectionType
            {
                public static string GET { get { return "GET"; } }
                public static string POST { get { return "POST"; } }
            }
            #endregion
     
     
     
     
        }
    }
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using System.Text;
     
    namespace HttpClient
    {
     
        /// <summary>
        ///包含服务器响应数据的对象
        /// </summary>
        public class ResultResponse
        {
            #region HttpWebResponse对象
            /// <summary>
            /// HttpWebResponse对象
            /// </summary>
            private HttpWebResponse m_response;
            #endregion
     
            #region 创建一个HttpWebResponse对象
            /// <summary>
            /// 创建一个HttpWebResponse对象
            /// </summary>
            /// <param name="_response">HttpWebResponse</param>
            public ResultResponse(HttpWebResponse _response)
            {
                this.m_response = _response;
            }
            #endregion
     
            #region 获取响应内容的二进制流
            /// <summary>
            /// 获取响应内容的二进制流 
            /// </summary>
            /// <returns></returns>
            public Stream GetResponseStream()
            {
                if (this.m_response != null)
                {
                    return this.m_response.GetResponseStream();
                }
                return null;
            }
            #endregion
     
            #region Http版本
            /// <summary>
            /// Http版本
            /// </summary>
            public string ProtocolVersion { get { return this.m_response != null ? this.m_response.ProtocolVersion.ToString() : ""; } }
            #endregion
            /// <summary>
            /// 响应方法
            /// </summary>
            public string Method { get { return this.m_response != null ? this.m_response.Method : ""; } }
            /// <summary>
            /// Http状态码
            /// </summary>
            public string StatusCode { get { return this.m_response != null ? this.m_response.StatusCode.ToString() : ""; } }
            /// <summary>
            /// Http响应头
            /// </summary>
            public WebHeaderCollection Headers { get { return this.m_response != null ? this.m_response.Headers : null;} }
     
            /// <summary>
            /// 响应流的字符编码
            /// </summary>
            /// <returns></returns>
            public Encoding getResponseEncoding()
            {
                if (this.m_response != null)
                {
                    return Encoding.GetEncoding(this.m_response.ContentEncoding);
                }
                return null;
            }
     
            /// <summary>
            /// 获取响应内容的字符串
            /// </summary>
            /// <param name="encoding">字符串编码(默认utf8)</param>
            /// <returns></returns>
            public string GetContent(string encoding="utf-8")
            {
                return System.Text.Encoding.GetEncoding(encoding).GetString(this.StreamtoBytes(this.GetResponseStream()));
    
    //            return System.Text.Encoding.GetEncoding(encoding).GetString(this.StreamtoBytes(this.GetResponseStream()));
            }
     
            /// <summary>
            /// 获取原始的HttpWebResponse
            /// </summary>
            /// <returns></returns>
            public HttpWebResponse GetRawResponse()
            {
                return this.m_response;
            }
     
            /// <summary>
            /// 二进制流转换成字节数组
            /// </summary>
            /// <param name="_stream"></param>
            /// <returns></returns>
            private byte[] StreamtoBytes(Stream _stream)
            {
                byte[] buff;
                int rlen;
                MemoryStream _ms;
                if (_stream != null)
                {
                    buff = new byte[1024];
                    rlen = 0;
                    _ms = new MemoryStream();
                    while ((rlen = _stream.Read(buff, 0, 1024)) > 0)
                    {
                        _ms.Write(buff, 0, rlen);
                    }
                    buff = _ms.ToArray();
                    _ms.Close();
                    _ms.Dispose();
                    return buff;
                }
                return null;
            }
        }
    }

  • 相关阅读:
    Golang flag包使用详解(一)
    string rune byte 的关系
    int在64位操作系统中占多少位?
    32位和64位系统区别及int字节数
    /etc/fstab修改及mkfs(e2label)相关应用与疑问
    nginx + fastcgi + c/c++
    MYSQL优化
    mysqlhighavailability
    woodmann--逆向工程
    jdaaaaaavid --github
  • 原文地址:https://www.cnblogs.com/txfd/p/10051097.html
Copyright © 2020-2023  润新知