function hookAjax(proxy) {
    // 保存真正的XMLHttpRequest对象
    window._ahrealxhr = window._ahrealxhr || XMLHttpRequest;
    XMLHttpRequest = function() {
        var xhr = new window._ahrealxhr;
        // 直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象
        Object.defineProperty(this, 'xhr', {
            value: xhr
        })
    };
    
    // 获取 XMLHttpRequest 对象的属性
    var prototype = window._ahrealxhr.prototype;
    for (var attr in prototype) {
        var type = "";
        try {
            type = typeof prototype[attr]
        } catch (e) {}
        if (type === "function") {
            XMLHttpRequest.prototype[attr] = hookfunc(attr);
        } else {
            // 给属性提供 getter、setter 方法
            Object.defineProperty(XMLHttpRequest.prototype, attr, {
                get: getFactory(attr),
                set: setFactory(attr),
                enumerable: true
            })
        }
    }
    
    function getFactory(attr) {
        return function() {
            // 判断对象是否包含特定的自身（非继承）属性
            var v = this.hasOwnProperty(attr + "_") ? this[attr + "_"] : this.xhr[attr];
            var attrGetterHook = (proxy[attr] || {})["getter"];
            return attrGetterHook && attrGetterHook(v, this) || v
        }
    }
    
    function setFactory(attr) {
        return function(v) {
            var xhr = this.xhr;
            var that = this;
            var hook = proxy[attr];
            if (typeof hook === "function") {  // 回调属性 onreadystatechange 等
                xhr[attr] = function() {
                	// ========================  修改 1 ==================
                    hook.call(that, xhr) || v.apply(xhr, arguments);
                }
            } else {
                //If the attribute isn't writeable, generate proxy attribute
                var attrSetterHook = (hook || {})["setter"];
                v = attrSetterHook && attrSetterHook(v, that) || v;
                
                // ========================  修改 2 ==================
                xhr[attr] = v;
                this[attr + "_"] = v;
            }
        }
    }
    
    function hookfunc(func) {
        return function() {
            var args = [].slice.call(arguments);
            
            // call() 方法调用一个函数, 其具有一个指定的this值和分别地提供的参数
            // 该方法的作用和 apply() 方法类似，只有一个区别，就是call()方法接受的是若干个参数的列表，而apply()方法接受的是一个包含多个参数的数组
            if (proxy[func]) {
                // ========================== 修改 3 ===============
                var result = proxy[func].call(this, args, this.xhr);
                if(result) {
                    return result;
                }
            }
            
            return this.xhr[func].apply(this.xhr, args);
        }
    }
    
    return window._ahrealxhr;
}

window.MyAjax = {
    hookedXHR: {},
    hookAjax: hookAjax,
    nativePost: nativePost,
    nativeCallback: nativeCallback
};
        
// 添加请求 Native 的代码
function nativePost(xhrId, params) {
    // TODO: 请求 Native
}

// Native 请求完成后调用该 JS 方法并且传入指定参数
function nativeCallback(xhrId, statusCode, responseText, responseHeaders, error) {
    var xhr = window.MyAjax.hookedXHR[xhrId];
    
    if(xhr.isAborted) { // 如果该请求已经手动取消了
        return;
    }
    
    if(error) {
        xhr.readyState = 1;
        if(xhr.onerror) {
            xhr.onerror();
        }
    } else {
        xhr.status = statusCode;
        xhr.responseText = responseText;
        xhr.readyState = 4;
        
        xhr.myResponseHeaders = responseHeaders;
        
        if(xhr.onreadystatechange) {
            xhr.onreadystatechange();
        }
        if(xhr.onload) {
            xhr.onload();
        }
    }
}

// hook ajax 方法
window.MyAjax.hookAjax({
    // 设置 RequestHeader 将参数保存，在 send 中将其一起发送给 Native
    setRequestHeader: function (arg, xhr) {
        if(!this.myHeaders) {
            this.myHeaders = {};
        }
        this.myHeaders[arg[0]] = arg[1];
    },
    getAllResponseHeaders: function (arg, xhr) {
        var headers = this.myResponseHeaders;
        if(headers) {
            if(typeof(headers) === 'object') {
                var result = '';
                for(var key in headers) {
                    result = result + key + ':' + headers[key] + '\r\n'
                }
                return result;
            }
            return headers;
        }
    },
    getResponseHeader: function (arg, xhr) {
        if(this.myResponseHeaders && this.myResponseHeaders(arg[0])) {
            return this.myResponseHeaders(arg[0]);
        }
    },
    // 保存 open 中的参数，在 send 中判断是否为 POST 方法
    open: function (arg, xhr) {
        this.myOpenArg = arg;
    },
    send: function (arg, xhr) {
        this.isAborted = false;
        if(this.myOpenArg[0] === 'POST') {
            var params = {};
            params.data = arg[0];
            params.method = 'POST';
            params.header = this.myHeaders;

            var url = this.myOpenArg[1];
            var location = window.location;
            if(!url.startsWith(location.protocol)) {
                url = location.origin + url;
            }
            params.url = url;

			// XMLHttpRequest 的标识符，用于 Native 返回时确认时哪个 XMLHttpRequest
            var xhrId = 'xhrId' + (new Date()).getTime();
            window.MyAjax.hookedXHR[xhrId] = this;
            
            window.MyAjax.nativePost(xhrId, params);

            // 通过 return true 可以阻止默认 Ajax 请求，不返回则会继续原来的请求
            return true;
        }
    },
    abort: function (arg, xhr) {
        if(this.myOpenArg[0] === 'POST') {
            if(xhr.onabort) {
                xhr.onabort()
            }
            return true;
        }
    }
    
});