晟骏ajax请求处理过程

最新推荐文章于 2024-05-20 17:54:23 发布
最新推荐文章于 2024-05-20 17:54:23 发布
阅读量68 收藏
点赞数
文章标签： ui json runtime
原文链接：http://www.cnblogs.com/JimmyHXD/archive/2012/08/02/2619681.html
版权

1.前段JS代码

//"UserAcess"：指定的类，"CheckLogin"：指定的方法，
//objparam:要传的参数，"function(response, options)":callback
AjaxHandle("UserAcess", "CheckLogin", objparam, function(response, options) {});


2请求跑到ajaxhandle.ashx文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using ShippingManager.Command;
using System.Web.SessionState;
using NoxTimer.Net.Apis;
using System.Text;

namespace ShippingManager
{
    /// <summary>
    /// Summary description for $codebehindclassname$
    /// </summary>
    [WebService(Namespace = "zybajaxHandle")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    public class AjaxHandler : IHttpHandler, IRequiresSessionState
    {

        public void ProcessRequest(HttpContext context)
        {
            
            string classname = context.Request.QueryString["classname"];//接收传入的类名
            string method = context.Request.QueryString["method"];//接收传入的方法
            if (!string.IsNullOrEmpty(classname) && !string.IsNullOrEmpty(method))
            {
                AjaxResult result = null;
                try
                {
                    PreInitPage();

                    RequstHandle handle = new RequstHandle();

                    result = handle.Handle(classname, method, context);
                }
                catch (Exception ex)
                {
                    result = new AjaxResult();
                    result.Success = false;
                    result.Message = ex.Message;
                    result.data = null;
                }
                context.Response.ContentType = "text/plain";
                context.Response.Write(result.ToJson());
                context.Response.End();
            }
            else
            {
                context.Response.ContentType = "text/html";
                context.Response.Write("找不到匹配方法");
                context.Response.End();
            }
            
        }

        public bool IsReusable
        {
            get
            {
                return false;
            }
        }

        private void PreInitPage()
        {
            if (!String.IsNullOrEmpty(System.Configuration.ConfigurationManager.AppSettings["CopyRight"]))
            {
                return;
            }
            AjaxResult resu = new EasyAjaxResult();
            long[] keyHandles;
            long keyNum = 0;
            uint appID = 0xffffffff;
            long nRet = NoxTimerAppApis.NoxFind(appID, out keyHandles, ref keyNum);
            if (nRet != 0)
            {
                resu.Success = false;
                resu.Message = "Error:" + NoxTimerAppApis.NoxGetLastError().ToString();
               HttpContext.Current.Response.Write(resu.ToJson());
               HttpContext.Current.Response.End();
            }
            String userPin = "79de3607198f9a27"; 
            nRet = NoxTimerAppApis.NoxOpen(keyHandles[0], userPin);
            if (nRet != 0)
            {
                resu.Success = false;
                resu.Message = "Error:" + NoxTimerAppApis.NoxGetLastError().ToString();
                HttpContext.Current.Response.Write(resu.ToJson());
                HttpContext.Current.Response.End();
            }
            ////获取硬件序列号
            //String sGUID = "";
            //nRet = NoxTimerAppApis.NoxGetUID(keyHandles[0], ref sGUID);
            //if (nRet != 0)
            //{
            //    Response.Write("HD No. Error");
            //}

            ////存储区读
            //byte[] readStorage = new byte[16];
            //if (0 != NoxTimerAppApis.NoxReadStorage(keyHandles[0], readStorage)) { }
            ////加密锁内存区写(8字节内存区)
            //byte[] memWData = new byte[8] { 91, 92, 93, 94, 95, 96, 97, 98 };
            //int v=  new Random().Next(10000000, 99999999);

            //byte[]  memWData = System.Text.Encoding.Default.GetBytes(v.ToString());

            //Application.Lock();
            //Application["_2345234536"] = v;
            //Application.UnLock();



            //if (0 != NoxTimerAppApis.NoxWriteMem(keyHandles[0], memWData)) {
            //    Response.Write("Error:"+NoxTimerAppApis.NoxGetLastError().ToString ());
            //}


            ////内存区读
            //byte[] memRData = new byte[8];
            //if (0 != NoxTimerAppApis.NoxReadMem(keyHandles[0], memRData))
            //{
            //    Response.Write("Error:" + NoxTimerAppApis.NoxGetLastError().ToString());
            //    Response.End();
            //}
            //else
            //{
            //    String str = Encoding.Default.GetString(memRData);
            //    if (str.CompareTo(Application["_2345234536"].ToString()) != 0)
            //    {
            //        Response.Write("HAHAHAHAHAHAHA");
            //        Response.Close();
            //    }
            //}


            ////获取加密锁时间模式、失效时间
            //long Mode, endYear, endMonth, endDay, endHour, endMinute;
            //Mode = 0;
            //endYear = 0;
            //endMonth = 0;
            //endDay = 0;
            //endHour = 0;
            //endMinute = 0;
            //nRet = NoxTimerAppApis.NoxGetExpiryDateTime(keyHandles[0], ref Mode, ref endYear, ref endMonth, ref endDay, ref endHour, ref endMinute);
            //if (nRet != 0)
            //{
            //    return;
            //}
            //String msg = String.Format("DateTime Successfuflly! Mode:" + Mode.ToString() + " endTimer:" + endYear.ToString() + "/"
            //                                                                                                        + endMonth.ToString() + "/"
            //                                                                                                        + endDay.ToString() + " "
            //                                                                                                        + endHour.ToString() + ":"
            //                                                                                                        + endMinute.ToString());



            //关闭加密锁
            NoxTimerAppApis.NoxClose(keyHandles[0]);

        }
    }
}
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Web;
using System.Runtime.Remoting;
namespace ShippingManager.Command
{
    /*
     
     */
    public class RequstHandle
    {
        /// <summary>
        /// 将类名和参数指定方法
        /// </summary>
        /// <param name="classname"></param>
        /// <param name="methodname"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public AjaxResult Handle(string classname, string methodname,HttpContext context)
        {
            AjaxResult result = null;
            string str = HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ApplicationPath);//请求的应用程序地址
            string path = str + @"bin\ShippingManager.DataAcess.dll";
            ObjectHandle ohandle = Activator.CreateInstanceFrom(path, "ShippingManager.DataAcess." + classname);
            if (ohandle != null)
            {
                System.Type t = ohandle.Unwrap().GetType();
                if (t != null)
                {
                    object o = Activator.CreateInstance(t);
                    //跑到指定的类中的方法！！（ajax方法请求+"on"指向方法名）
                    MethodInfo minfo = t.GetMethod("on" + methodname, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
                    if (minfo != null)
                    {
                        object[] parmas = new object[] { context };
                        //
                        result = (AjaxResult)minfo.Invoke(o, parmas);
                    }
                    else
                    {
                        result = new AjaxResult();
                        result.Success = false;
                        result.Message = "找不到匹配方法：" + methodname;
                    }
                }
                else
                {
                    result = new AjaxResult();
                    result.Success = false;
                    result.Message = "找不到匹配类：" + classname;
                }
            }
            else
            {
                result = new AjaxResult();
                result.Success = false;
                result.Message = "找不到ShippingManager.DataAcess.dll";
            }
            return result;
           
        }
        /// <summary>
        /// 从httpcontext中创建实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="context"></param>
        /// <returns></returns>
        public static T GenerateEntity<T>(HttpContext context)
        {
            Type enumType = typeof(T);
            if (enumType.IsGenericType)
            {
                T obj = Activator.CreateInstance<T>();
                SetListValue<T>(context, 0, obj);
                return obj;
            }
            else
            {
                T obj = Activator.CreateInstance<T>();
                PropertyInfo[] pinfo = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
                foreach (PropertyInfo p in pinfo)
                {
                    string str = context.Request[p.Name];
                    if (!string.IsNullOrEmpty(str))
                    {
                        p.SetValue(obj, TypeConvert(str, p.PropertyType), null);
                    }
                }
                return obj;
            }
        }
        
        /// <summary>
        /// 递归创建添加泛型实例，如list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="context"></param>
        /// <param name="index"></param>
        /// <param name="iList"></param>
        private static void SetListValue<T>(HttpContext context, int index,T iList)
        {
            Type[] genericArguments = typeof(T).GetGenericArguments();
            if (genericArguments.Length > 0)
            {
                System.Type enumType = genericArguments[0];
                object obj = Activator.CreateInstance(enumType);
                PropertyInfo[] pinfo = enumType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
                bool allisNull = true;
                foreach (PropertyInfo p in pinfo)
                {
                    if (context.Request[p.Name + "_" + index.ToString()] != null)
                    {
                        string str = context.Request[p.Name + "_" + index.ToString()];
                        p.SetValue(obj, TypeConvert(str, p.PropertyType), null);
                        allisNull = false;
                    }
                }
                if (allisNull)
                {
                    return;
                }
                MethodInfo addMList = typeof(T).GetMethod("Add");
                addMList.Invoke(iList, new object[] { obj });
            }
            SetListValue<T>(context, index + 1, iList);
        }
        /// <summary>
        /// 从httpcontext中创建实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="context"></param>
        /// <returns></returns>
        public static T GenerateListEntity<T>(HttpContext context)
        {
            Type enumType = typeof(T);
            if (enumType.IsGenericType)
            {
                T obj = Activator.CreateInstance<T>();
                SetListValueWidthTypeName<T>(context, 0, obj);
                return obj;
            }
            else
            {
                T obj = Activator.CreateInstance<T>();
                PropertyInfo[] pinfo = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
                foreach (PropertyInfo p in pinfo)
                {
                    string str = context.Request[p.Name];
                    if (!string.IsNullOrEmpty(str))
                    {
                        p.SetValue(obj, TypeConvert(str, p.PropertyType), null);
                    }
                }
                return obj;
            }
        }
        /// <summary>
        /// 递归创建添加泛型实例，如list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="context"></param>
        /// <param name="index"></param>
        /// <param name="iList"></param>
        private static void SetListValueWidthTypeName<T>(HttpContext context, int index, T iList)
        {
            Type[] genericArguments = typeof(T).GetGenericArguments();
            if (genericArguments.Length > 0)
            {
                System.Type enumType = genericArguments[0];
                object obj = Activator.CreateInstance(enumType);
                PropertyInfo[] pinfo = enumType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
                bool allisNull = true;
                foreach (PropertyInfo p in pinfo)
                {
                    if (context.Request[enumType.Name + "_" + p.Name + "_" + index.ToString()] != null)
                    {
                        string str = context.Request[enumType.Name + "_" + p.Name + "_" + index.ToString()];
                        p.SetValue(obj, TypeConvert(str, p.PropertyType), null);
                        allisNull = false;
                    }
                }
                if (allisNull)
                {
                    return;
                }
                MethodInfo addMList = typeof(T).GetMethod("Add");
                addMList.Invoke(iList, new object[] { obj });
            }
            SetListValueWidthTypeName<T>(context, index + 1, iList);
        }
        public static T GenerateEntity<T>(System.Web.UI.ControlCollection controls)
        {
            T obj = Activator.CreateInstance<T>();
            IEnumerable<System.Web.UI.HtmlControls.HtmlForm> form = controls.OfType<System.Web.UI.HtmlControls.HtmlForm>();
            if (form != null && form.Count() > 0)
            {
                IEnumerable<System.Web.UI.WebControls.WebControl> allcontrol = form.First().Controls.OfType<System.Web.UI.WebControls.WebControl>();
                IEnumerable<System.Web.UI.HtmlControls.HtmlControl> htmlcontrol = form.First().Controls.OfType<System.Web.UI.HtmlControls.HtmlControl>();
                PropertyInfo[] pinfo = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
                foreach (PropertyInfo p in pinfo)
                {
                    var contros = allcontrol.Where(item => item.ID.StartsWith("con") && (item.ID.Substring(3) == p.Name) || item.ID.Contains(p.Name));
                    var htmlcons = htmlcontrol.Where(item => item.ID.StartsWith("con") && (item.ID.Substring(3) == p.Name) || item.ID.Contains(p.Name));
                    if (contros.Count() > 0)
                    {
                        System.Web.UI.WebControls.WebControl c = contros.First();
                        SetProperptyValue(p, c, obj);
                    }
                    else if (htmlcons.Count() > 0)
                    {
                        System.Web.UI.HtmlControls.HtmlControl c = htmlcons.First();
                        SetProperptyValue(p, c, obj);
                    }
                }
            }
            return obj;
        }
        private static void SetProperptyValue(PropertyInfo p, System.Web.UI.Control c, object obj)
        {
            Type t = c.GetType();
            if (t == typeof(System.Web.UI.WebControls.TextBox))
            {
                p.SetValue(obj, TypeConvert(((System.Web.UI.WebControls.TextBox)c).Text.Trim(), p.PropertyType), null);
            }
            else if (t == typeof(System.Web.UI.WebControls.DropDownList))
            {
                p.SetValue(obj, TypeConvert(((System.Web.UI.WebControls.DropDownList)c).SelectedValue, p.PropertyType), null);
            }
            else if (t == typeof(System.Web.UI.WebControls.RadioButtonList))
            {
                p.SetValue(obj, TypeConvert(((System.Web.UI.WebControls.RadioButtonList)c).SelectedValue, p.PropertyType), null);
            }
            else if (t == typeof(System.Web.UI.WebControls.Label))
            {
                p.SetValue(obj, TypeConvert(((System.Web.UI.WebControls.Label)c).Text.Trim(), p.PropertyType), null);
            }
            else if (t == typeof(System.Web.UI.WebControls.CheckBox))
            {
                p.SetValue(obj, TypeConvert(((System.Web.UI.WebControls.CheckBox)c).Checked ? "1" : "0", p.PropertyType), null);
            }
            else if (t == typeof(System.Web.UI.HtmlControls.HtmlInputHidden))
            {
                p.SetValue(obj, TypeConvert(((System.Web.UI.HtmlControls.HtmlInputHidden)c).Value, p.PropertyType), null);
            }
            else if (t == typeof(System.Web.UI.HtmlControls.HtmlInputText))
            {
                p.SetValue(obj, TypeConvert(((System.Web.UI.HtmlControls.HtmlInputText)c).Value.Trim(), p.PropertyType), null);
            }
        }
        public static void SetControlValue(System.Web.UI.ControlCollection controls, object obj)
        {
            if (obj != null)
            {
                IEnumerable<System.Web.UI.HtmlControls.HtmlForm> form = controls.OfType<System.Web.UI.HtmlControls.HtmlForm>();
                if (form != null && form.Count() > 0)
                {
                    IEnumerable<System.Web.UI.WebControls.WebControl> allcontrol = form.First().Controls.OfType<System.Web.UI.WebControls.WebControl>();
                    IEnumerable<System.Web.UI.HtmlControls.HtmlControl> htmlcontrol = form.First().Controls.OfType<System.Web.UI.HtmlControls.HtmlControl>();
                    PropertyInfo[] pinfo = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
                    foreach (PropertyInfo p in pinfo)
                    {
                        IEnumerable<System.Web.UI.WebControls.WebControl> contros;
                        IEnumerable<System.Web.UI.HtmlControls.HtmlControl> htmlcons;
                         if (p.PropertyType.IsEnum)
                        {
                             contros = allcontrol.Where(item => item.ID.StartsWith("con") && (item.ID.Substring(3) == p.Name) || item.ID.Contains(p.Name));
                             htmlcons = htmlcontrol.Where(item => item.ID.StartsWith("con") && (item.ID.Substring(3) == p.Name) || item.ID.Contains(p.Name));
                        }
                        else
                        {
                             contros = allcontrol.Where(item => item.ID.StartsWith("con") && item.ID.Substring(3) == p.Name);
                             htmlcons = htmlcontrol.Where(item => item.ID.StartsWith("con") && item.ID.Substring(3) == p.Name);
                        }
                        
                        if (contros.Count() > 0)
                        {
                            System.Web.UI.WebControls.WebControl c = contros.First();
                            SetCValue(p, c, obj);
                        }
                        else if (htmlcons.Count() > 0)
                        {
                            System.Web.UI.HtmlControls.HtmlControl c = htmlcons.First();
                            SetCValue(p, c, obj);
                        }
                    }
                }
            }
        }
       
        private static void SetCValue(PropertyInfo p, System.Web.UI.Control c, object obj)
        {
            Type t = c.GetType();
            if (t == typeof(System.Web.UI.WebControls.TextBox))
            {
                ((System.Web.UI.WebControls.TextBox)c).Text=GetPropertyValue(p,obj);
            }
            else if (t == typeof(System.Web.UI.WebControls.DropDownList))
            {
                try
                {
                    string thevalue = GetPropertyValue(p, obj);
                    if (!string.IsNullOrEmpty(thevalue))
                    {
                        ((System.Web.UI.WebControls.DropDownList)c).SelectedValue = thevalue;
                    }
                }
                catch {
                    System.Web.UI.WebControls.DropDownList ddl = ((System.Web.UI.WebControls.DropDownList)c);
                    if (ddl.Items.Count > 0) ddl.SelectedValue = ddl.Items[0].Value;
                    else ddl.SelectedValue = null;
                }
            }
            else if (t == typeof(System.Web.UI.WebControls.Label))
            {
                ((System.Web.UI.WebControls.Label)c).Text = GetPropertyValue(p, obj);
            }
            else if (t == typeof(System.Web.UI.WebControls.RadioButtonList))
            {
                ((System.Web.UI.WebControls.RadioButtonList)c).SelectedValue = GetPropertyValue(p, obj);
            }
            else if (t == typeof(System.Web.UI.WebControls.CheckBox))
            {
                ((System.Web.UI.WebControls.CheckBox)c).Checked = (bool)TypeConvert(GetPropertyValue(p, obj), typeof(bool));
            }
            else if (t == typeof(System.Web.UI.HtmlControls.HtmlInputHidden))
            {
                ((System.Web.UI.HtmlControls.HtmlInputHidden)c).Value = GetPropertyValue(p, obj);
            }
            else if (t == typeof(System.Web.UI.HtmlControls.HtmlInputText))
            {
                ((System.Web.UI.HtmlControls.HtmlInputText)c).Value = GetPropertyValue(p, obj);
            }
        }
        private static string GetPropertyValue(PropertyInfo p, object obj)
        {
            object pobj = p.GetValue(obj, null);
            if (pobj != null)
            {
                if (p.PropertyType == typeof(DateTime))
                {
                    if (Convert.ToDateTime(pobj).Equals(new DateTime(1900, 1, 1)))
                    {
                        return string.Empty;
                    }
                }
                else if (p.PropertyType.IsEnum)
                {
                    Type enumType = p.PropertyType.UnderlyingSystemType;

                    int i = (int)Enum.Parse(enumType, p.GetValue(obj, null).ToString());
                    return i.ToString();

                }
                return pobj.ToString();
            }
            else return string.Empty;
        }
        public static object TypeConvert(string value, Type type)
        {
            Type enumType = type;
            if (enumType.IsGenericType && (enumType.GetGenericTypeDefinition() == typeof(Nullable<>)))
            {
                Type[] genericArguments = enumType.GetGenericArguments();
                if (genericArguments.Length > 0)
                {
                    enumType = genericArguments[0];
                }
            }
            if (typeof(int) == enumType)
            {
                if (value.ToLower() == "true") return 1;
                else if (value.ToLower() == "false") return 0;
                else
                {
                    int temp = 0;
                    int.TryParse(value, out temp);
                    return temp;
                }
            }
            if (typeof(double) == enumType)
            {
                double temp = 0.0;
                double.TryParse(value, out temp);
                return temp;
            }
            if (typeof(decimal) == enumType)
            {
                decimal temp = 0;
                decimal.TryParse(value, out temp);
                return temp;
            }
            if (typeof(bool) == enumType)
            {
                return toBool(value);
            }
            if (typeof(byte) == enumType)
            {
                return Convert.ToByte(value);
            }
            if (typeof(char) == enumType)
            {
                return Convert.ToChar(value);
            }
            if (typeof(DateTime) == enumType)
            {
                return toDate(value);
            }
            if (typeof(float) == enumType)
            {
                float temp = 0f;
                float.TryParse(value, out temp);
                return temp;
            }
            if (typeof(short) == enumType)
            {
                short temp = 0;
                short.TryParse(value, out temp);
                return temp;
            }
            if (typeof(long) == enumType)
            {
                long temp = 0L;
                long.TryParse(value, out temp);
                return temp;
            }
            if (enumType.IsEnum)
            {
                return Enum.Parse(enumType, value);
            }
            return value;
        }

        private static bool toBool(string boolStr)
        {
            if ((string.IsNullOrEmpty(boolStr) || (boolStr.ToLower() == "false")) || (boolStr == "0"))
            {
                return false;
            }
            return true;
        }

        private static DateTime toDate(string dateStr)
        {
            if (string.IsNullOrEmpty(dateStr))
            {
                return DateTime.MinValue;
            }
            try
            {
                return DateTime.Parse(dateStr);
            }
            catch
            {
                return DateTime.MinValue;
            }
        }



    }
}

3.Invoke的使用

 

现在已处理登录页面的请求为例：

1.Login.aspx

 function Login() {
        var loginame = document.getElementById("txtloginname").value;
        var pwd = document.getElementById("txtpwd").value;
        var objparam = { LoginName: loginame, Password: pwd };
        //
        AjaxHandle("UserAcess", "CheckLogin", objparam, function(response, options) {
            var json = response.responseText;
            var obj = parseJsonResult(json);
            if (obj != null && obj.Success) {
                location.href = 'Main.aspx';
            }
            else {
                Ext.MessageBox.alert("错误", obj.Message, function(btn) {

                });
            }
        });
    }

2。经过上面介绍发送到ajaxhandle.ashx，经过ajaxresult.cs,使用Invoke 到了要处理的UserAccess.cs

        public AjaxResult onCheckLogin(System.Web.HttpContext context)
        {
            AjaxResult result = new AjaxResult();
            try
            {
                //成功登陆的USER对象
                Users user = CanLogin(context.Request["LoginName"], context.Request["Password"]);
                if (user != null)
                {
                    object obj = System.Web.HttpContext.Current.Cache.Get(user.UserGUID);
                    if (obj == null || obj+""=="")
                    {
                        //记录user对象的登陆时间
                       TimeSpan SessTimeout = new TimeSpan(0, 0, System.Web.HttpContext.Current.Session.Timeout, 0,0);

                        System.Web.HttpContext.Current.Cache.Insert(user.UserGUID, user.LoginName, null, DateTime.MaxValue, 
                          SessTimeout, System.Web.Caching.CacheItemPriority.NotRemovable, null);

                     
                      
                        result.Success = true;
                        //有啥用呢？
                        UserUtil.CurrentUser = user;
                        result.data = user;

                    }
                    else
                    {
                        result.Success = false;
                        result.Message = "登录错误，用户已经登录！";
                    }
                }
                else
                {
                    result.Success = false;
                    result.Message = "用户名或密码错误！";
                }
            }
            catch (Exception ex)
            {
                result.Success = false;
                result.Message = ex.Message;
            }
            return result;
        }

 

转载于:https://www.cnblogs.com/JimmyHXD/archive/2012/08/02/2619681.html

aidong4639
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java后台判断ajax请求及处理过程详解
08-19
主要介绍了Java后台判断ajax请求及处理过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
AJAX陷阱
黑夜给了我黑色的眼睛，我却用它来寻找光明。
02-01 1144
一.AJAX在FF(Firefox)上同步请求的问题.最近在使用AJAX过程中发现:IE和FF(firefox)对异步请求(即open时用ture参数)的支持都正常,但在处理同步请求时表现不一,IE支持很好,FF在调用send时却会freeze up,好象假死,并且在收到响应后不会fire(激活)用onreadystatechange注册的回调函数,也就是说下面的handle_upload_fla
Ajax请求的五个步骤
热门推荐
chaopingyao的博客
06-02 16万+
Ajax请求的五个步骤 一、定义 1、什么是Ajax Ajax：即异步 JavaScript 和XML。Ajax是一种用于创建快速动态网页的技术。通过在后台与服务器进行少量数据交换，Ajax可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。而传统的网页(不使用 Ajax)如果需要更新内容，必需重载整个网页面。 2、同步与异步的区别 同步提交：当用户发送请求时，当前页面不可以使用，服务器响应页面到客户端，响应完成，用户才可以使用页面。 异步提交：当用户发送请
前端Ajax请求超时处理
向着高亮的地方
07-09 1万+
1、步骤解析： 第一步：将网络请求事件赋值给变量ajaxTimeOut 第二步：通过设置timeout属性值，来定义超时时间 第三步：通过complete中的status是否等于timeout来判断是否超时，并设置超时提示处理 2、具体代码 let ajaxTimeOut = $.ajax({ //将网络请求事件赋值给变量ajaxTimeOut url: "/api_v1...
java的ajax请求_Java后台判断ajax请求及处理过程详解
weixin_35662171的博客
02-12 3411
一、问题描述：当访问一个需要登录的页面时，会有过滤器或者拦截器进行过滤拦截，如果用户没有登录，则跳转到登录页面。当用户已经登录进入系统后，然后长时间没操作，等到session过期后，再点击一个ajax请求操作时，这时再跳转到登录页面就不合适了，因为这是ajax操作，拦截后跳到页面返回的结果js识别不了。二、解决方法：在过滤器或者拦截器上做识别，针对页面跳转请求和ajax请求分别处理。页面跳转的不再...
Ajax 请求的五大步骤
努力努力再努力的博客
05-11 2万+
什么是 Ajax Ajax ： 即 异步JavaScript 和 XML ，Ajax 是一种用于创建快速动态网页的技术。通过在后台与服务器进行少量数据交换，Ajax 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新，而传统不使用Ajax的网页，如果需要更新内容，必需重载整个网页面。 Ajax 的工作原理 Ajax 的工作原理相当关于在用户和服务器之间加了一个中间层（Ajax 引擎），使用户操作与服务器响应异步化，并不是所有的用户请求都提交给服务器。像一些数据验证和数据
Ajax请求
weixin_45030426的博客
03-25 9956
ajax请求简介： ajax是利用前端的技术，向服务器发送一个异步请求 原有的请求在请求后需要刷新整张页面，
详解Ajax请求
qq_49900295的博客
03-30 2万+
目录 1.$.get()函数的语法 2.$.get()发起不带参数的请求 3.$.get()发起带参数的请求 4.$.post()函数的语法 5.$.post()向服务器提交数据 6.$.ajax()函数的语法 7.使用$.ajax()发起GET请求 ​8.使用$.ajax()发起POST请求 1.$.get()函数的语法 jQuery中$.get()函数的功能单一，专门用来发起get请求，从而将服务器上的资源请求到客户端来进行使用。 $.get()函数的语法如下： $..
ajax请求传递参数的方式,Ajax请求 一般处理程序参数传递的几种方式
weixin_42513616的博客
08-05 3915
//第一种Ajax请求$.ajax({type:"GET", //请求类型，有get,post等类型，和表单提交是一样的url:"Result.aspx", //请求处理的页面,就是说由那个页面捕获请求，同样这个路径可以换成ashx，一般处理程序data: "name=John&location=Boston", //传递参数，实在就是(Result.aspx?name=John&a...
Ajax 请求的基本步骤
m0_51528800的博客
05-20 3319
Ajax 请求的基本步骤 Ajax 请求的基本步骤一、Ajax的定义二、Ajax的工作原理三、Ajax请求的基本步骤1、创建XMLHttpRequest对象2、创建HTTP请求3、设置响应HTTP 请求状态变化的函数4、设置获取服务器返回数据的语句5、发送HTTP请求 一、Ajax的定义 Ajax：即异步 JavaScript 和XML。Ajax是一种用于创建快速动态网页的技术。通过在后台与服务器进行少量数据交换，Ajax可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行
ajax前台后台跨域请求处理方式
08-28
本篇文章通过前台跨域请求处理以及后台跨域的数据处理方式介绍，详细分析了ajax跨域的问题，对此有需要的朋友学习下。
C# 如何使用ajax请求
08-18
主要介绍了C# 如何使用ajax请求，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Ajax在请求过程中显示进度的简单实现
10-23
ajax技术在web应用中使用非常频繁，本文以asp.net MVC为示例，提供一种简单的实现方式。ajax在请求过程中显示进度条，是怎么实现的呢？本文通过代码和文字说明相结合的方式分享给大家。
实例详解Android Webview拦截ajax请求
08-28
本篇内容主要给大家讲解了Android Webview拦截ajax请求的详细讲解，需要的朋友一起来学习一下。
ajax请求的五个步骤
ajdhakj6的博客
09-12 3436
ajax请求的五个步骤
Unity射击游戏开发教程：（19）控制生命进度条
网易搬砖选手
05-17 47
我们不希望当前的健康状况超过最大健康状况，因此我们使用 If Then 来检查此情况，如果发生这种情况，我们会将当前值设置为最大值。在此游戏对象中，我们将添加到 UI 图像中，这些图像将作为生命值栏的填充和轮廓。回到检查器，我们将脚本附加到健康栏，将填充图像分配给填充变量并将最大值设置为我们想要的值。我们需要初始化的变量是两个整数，分别是生命值“条”的最大值和玩家生命值的当前值。对于每个UI图像，我们只需将之前上传的精灵图像拖到填充图像中，因为它是白色的，所以我们可以将颜色更改为我们想要的任何颜色。
python+selenium - UI自动框架之封装log类
weixin_41708323的博客
05-16 276
每次调用log函数，会根据绝对路径生成日志文件在logs目录下面(在被调用的时候日志会输出到指定的文件），日志文件的格式是年月日.log；通过自定log类，能把执行过程记录到日志，方便检查和重现问题。
Ollama + (Anythingllm / Open WebUI / MaxKB)搭建本地大模型
最新发布
yong472727322的博客
05-20 403
重命名镜像（如果是通过代理下载的） docker tag ghcr.dockerproxy.com/open-webui/open-webui:main ghcr.io/open-webui/open-webui:main。3. 在[Service]下添加OLLAMA_MODELS环境变量，目录需要配置权限给【ollama用户及用户组】1. 进入配置默认目录：cd /etc/systemd/system/# 删除代理镜像（如果是通过代理下载的）2、（可选）使用代理拉取镜像。1、下载Ollama。
如何理解ajax 请求处理的过程
05-27
Ajax 请求处理的过程可以分为以下几个步骤： 1. 创建 XMLHttpRequest 对象：使用 JavaScript 创建 XMLHttpRequest 对象，该对象用于向服务器发送请求和获取响应数据。 2. 设置请求参数：通过 XMLHttpRequest 对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值