如果在网页中进行Ajax请求或使用Selenium Web驱动程序拦截XMLHttpRequest，则使用Java Script进行跟踪

Question

我正在使用Selenium WebDriver来抓取一个网站 （例如，我也将抓取其他网站！），它具有无限滚动。

问题陈述：

向下滚动无限滚动页面，直到内容停止使用Selenium Web驱动程序加载。

我的方法：目前我这样做 -

第1步：滚动到页面底部

JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("javascript:window.onload=toBottom();"+
                        "function toBottom(){" +
                        "window.scrollTo(0,Math.max(document.documentElement.scrollHeight," +
                        "document.body.scrollHeight,document.documentElement.clientHeight));" +
                "}");

然后我等待一段时间让Ajax请求像这样完成 -

第2步：明确等待Ajax请求结束

了Thread.sleep（1000）;

然后我给另一个java脚本来检查页面是否可滚动

第3步：检查页面是否可滚动

//Alternative to document.height is to be used which is document.body.clientHeight
//refer to https://developer.mozilla.org/en-US/docs/DOM/document.height

    if((Long)js.executeScript("return " +
                                "(document.body.clientHeight-(window.pageYOffset + window.innerHeight))")>0)

如果上述条件为真，那么我重复步骤1 - 3，直到步骤3中的条件为假。

问题：我不想给Thread.sleep(1000); 在步骤2中，我想在后台Ajax请求结束时使用Java Script检查，如果步骤3中的条件为真，则进一步向下滚动。

PS：我不是页面的开发者，因此我无法访问运行页面的代码，我可以在网页中注入java脚本（如步骤1和3中所示）。 并且，我必须在无限滚动期间为任何具有Ajax请求的网站编写通用逻辑。

我将感激有些人可以在这里休息一下！

编辑：好的，经过2天的努力，我发现我通过Selenium WebDriver抓取的页面可以包含任何这些JavaScript库 ，我将不得不根据不同的库进行池化，例如，使用jQuery api的web应用程序，我可能正在等待

(Long)((JavascriptExecutor)driver).executeScript("return jQuery.active")

返回零。

同样，如果Web应用程序使用Prototype JavaScript库，我将不得不等待

(Long)((JavascriptExecutor)driver).executeScript("return Ajax.activeRequestCount")

返回零。

现在 ， 问题是如何编写可以处理大多数可用JavaScript库的通用代码？

我在实施这个问题时面临的问题 -

1 。 如何找到Web应用程序中使用的JavaScript库（使用Java中的Selenium WebDriver），以便我可以编写相应的等待方法？ 目前，我正在使用它

码

2 。 这样我就不得不为单独的JavaScript库编写多达77种方法，因此，我还需要一种更好的方法来处理这种情况。

简而言之，我需要通过Selenium Web Driver的java实现来确定浏览器是否使用或不使用任何JavaScript库进行任何调用（Ajax或简单）

PS：Chorme的JavaScript Lib探测器和Firefox的JavaScript Library探测器都有附加功能，可以检测正在使用的JavaScript库。

Answer 1

对于在无限滚动期间使用Ajax Response并使用jQuery API（或其他操作）的网页，在开始打开网页之前。

    //Inject the pooling status variable
    js.executeScript("window.status = 'fail';");

    //Attach the Ajax call back method
    js.executeScript( "$(document).ajaxComplete(function() {" +
    "status = 'success';});");

第1步：将保留原始问题中的相同内容

步骤2汇集以下脚本（这是不需要Thread.Sleep()并使逻辑更动态的脚本）

String aStatus = (String)js.executeScript("return status;");

                        if(aStatus!=null && aStatus.equalsIgnoreCase("success")){
                            js.executeScript("status = 'fail';");
                            break poolingLoop;
                        }

第3步：现在不需要！

结论：无需提供钝的Thread.sleep（）; 使用Selenium WebDriver时一次又一次!!

只有在Web应用程序中使用jQuery api时，此方法才有效。

编辑：根据@jayati给出的链接，我注入了javascript-

Javascript一：

//XMLHttpRequest instrumentation/wrapping
var startTracing = function (onnew) {
    var OldXHR = window.XMLHttpRequest;

    // create a wrapper object that has the same interfaces as a regular XMLHttpRequest object
    // see http://www.xulplanet.com/references/objref/XMLHttpRequest.html for reference on XHR object
    var NewXHR = function() {
        var self = this;
        var actualXHR = new OldXHR();

        // private callbacks (for UI):
        // onopen, onsend, onsetrequestheader, onupdate, ...
        this.requestHeaders = "";
        this.requestBody = "";

        // emulate methods from regular XMLHttpRequest object
        this.open = function(a, b, c, d, e) { 
            self.openMethod = a.toUpperCase();
            self.openURL = b;
            ajaxRequestStarted = 'open';

            if (self.onopen != null && typeof(self.onopen) == "function") { 
                self.onopen(a,b,c,d,e); } 
            return actualXHR.open(a,b,c,d,e); 
        }
        this.send = function(a) {
            ajaxRequestStarted = 'send';

            if (self.onsend != null && typeof(this.onsend) == "function") { 
                self.onsend(a); } 
            self.requestBody += a;
            return actualXHR.send(a); 
        }
        this.setRequestHeader = function(a, b) {
            if (self.onsetrequestheader != null && typeof(self.onsetrequestheader) == "function") { self.onsetrequestheader(a, b); } 
            self.requestHeaders += a + ":" + b + "\r\n";
            return actualXHR.setRequestHeader(a, b); 
        }
        this.getRequestHeader = function() {
            return actualXHR.getRequestHeader(); 
        }
        this.getResponseHeader = function(a) { return actualXHR.getResponseHeader(a); }
        this.getAllResponseHeaders = function() { return actualXHR.getAllResponseHeaders(); }
        this.abort = function() { return actualXHR.abort(); }
        this.addEventListener = function(a, b, c) { return actualXHR.addEventListener(a, b, c); }
        this.dispatchEvent = function(e) { return actualXHR.dispatchEvent(e); }
        this.openRequest = function(a, b, c, d, e) { return actualXHR.openRequest(a, b, c, d, e); }
        this.overrideMimeType = function(e) { return actualXHR.overrideMimeType(e); }
        this.removeEventListener = function(a, b, c) { return actualXHR.removeEventListener(a, b, c); }

        // copy the values from actualXHR back onto self
        function copyState() {
            // copy properties back from the actual XHR to the wrapper
            try {
                self.readyState = actualXHR.readyState;
            } catch (e) {}
            try {
                self.status = actualXHR.status;
            } catch (e) {}
            try {
                self.responseText = actualXHR.responseText;
            } catch (e) {}
            try {
                self.statusText = actualXHR.statusText;
            } catch (e) {}
            try {
                self.responseXML = actualXHR.responseXML;
            } catch (e) {}
        }

        // emulate callbacks from regular XMLHttpRequest object
        actualXHR.onreadystatechange = function() {
            copyState();

            try {
                if (self.onupdate != null && typeof(self.onupdate) == "function") { self.onupdate(); } 
            } catch (e) {}

            // onreadystatechange callback            
            if (self.onreadystatechange != null && typeof(self.onreadystatechange) == "function") { return self.onreadystatechange(); } 
        }
        actualXHR.onerror = function(e) {

            ajaxRequestComplete = 'err';
            copyState();

            try {
                if (self.onupdate != null && typeof(self.onupdate) == "function") { self.onupdate(); } 
            } catch (e) {}

            if (self.onerror != null && typeof(self.onerror) == "function") { 
                return self.onerror(e); 
            } else if (self.onreadystatechange != null && typeof(self.onreadystatechange) == "function") { 
                return self.onreadystatechange(); 
            }
        }
        actualXHR.onload = function(e) {

            ajaxRequestComplete = 'loaded';
            copyState();

            try {
                if (self.onupdate != null && typeof(self.onupdate) == "function") { self.onupdate(); } 
            } catch (e) {}

            if (self.onload != null && typeof(self.onload) == "function") { 
                return self.onload(e); 
            } else if (self.onreadystatechange != null && typeof(self.onreadystatechange) == "function") { 
                return self.onreadystatechange(); 
            }
        }
        actualXHR.onprogress = function(e) {
            copyState();

            try {
                if (self.onupdate != null && typeof(self.onupdate) == "function") { self.onupdate(); } 
            } catch (e) {}

            if (self.onprogress != null && typeof(self.onprogress) == "function") { 
                return self.onprogress(e);
            } else if (self.onreadystatechange != null && typeof(self.onreadystatechange) == "function") { 
                return self.onreadystatechange(); 
            }
        }

        if (onnew && typeof(onnew) == "function") { onnew(this); }
    }

    window.XMLHttpRequest = NewXHR;

}
window.ajaxRequestComplete = 'no';//Make as a global javascript variable
window.ajaxRequestStarted = 'no';
startTracing();

或Javascript二：

var startTracing = function (onnew) {
    window.ajaxRequestComplete = 'no';//Make as a global javascript variable
    window.ajaxRequestStarted = 'no';

    XMLHttpRequest.prototype.uniqueID = function() {
        if (!this.uniqueIDMemo) {
            this.uniqueIDMemo = Math.floor(Math.random() * 1000);
        }
        return this.uniqueIDMemo;
    }

    XMLHttpRequest.prototype.oldOpen = XMLHttpRequest.prototype.open;

    var newOpen = function(method, url, async, user, password) {

        ajaxRequestStarted = 'open';
        /*alert(ajaxRequestStarted);*/
        this.oldOpen(method, url, async, user, password);
    }

    XMLHttpRequest.prototype.open = newOpen;

    XMLHttpRequest.prototype.oldSend = XMLHttpRequest.prototype.send;

    var newSend = function(a) {
        var xhr = this;

        var onload = function() {
            ajaxRequestComplete = 'loaded';
            /*alert(ajaxRequestComplete);*/
        };

        var onerror = function( ) {
            ajaxRequestComplete = 'Err';
            /*alert(ajaxRequestComplete);*/
        };

        xhr.addEventListener("load", onload, false);
        xhr.addEventListener("error", onerror, false);

        xhr.oldSend(a);
    }

    XMLHttpRequest.prototype.send = newSend;
}
startTracing();

并且在java代码中检查状态变量ajaxRequestStarted, ajaxRequestComplete的状态，可以确定ajax是否已启动或已完成。

现在我有办法等到Ajax完成，我还可以找到Ajax是否在某个动作上被触发

Answer 2

方法1 ：

你的方法很好，只需做一些改动即可：

步骤1：改进此步骤以使用window.setInterval定期调用toBottom函数。 在(c >= totalcount)调用window.clearInterval

Setp 2：检查是否(c >= totalcount) ，而不是检查页面是否可滚动。 并且这个条件每200ms直到(c >= totalcount)返回true。

仅供参考：如果步骤1在所有浏览器中都不起作用，那么您可以参考Tata-Nano-Reviews-925076578.js的5210行，并使用c变量检查调用它。

方法2 ：

转到jQuery API并输入“ajax”。 您可以找到一些可用于ajax请求的回调处理程序。

可能在请求发送之前和适当接收之后设置变量。

在两者之间使用你原来的定期滚动到底部的方法，除非你不能再滚动。 此时清除区间变量。

现在，定期检查该间隔变量是否为空。 Null意味着你已达到底部。

Answer 3

我们必须解决相同的问题，并使用长Javascript函数进行管理。 只需要添加检查以查看哪个库未定义。

PS感谢您给我一个简单的答案，如何检查正在进行原型请求！

例如。 处理JQuery和XHR / Prototype

var jsExecutor = /*Get your WebDriverInstance*/ as IJavaScriptExecutor;
while(/*your required timeout here*/)
{
    var ajaxComplete = 
      jsExecutor.ExecuteScript("return ((typeof Ajax === 'undefined') ||   
      Ajax.activeRequestCount == 0) && ((typeof jQuery === 'undefined') || $.active == 0)");
    if (ajaxIsComplete)
      return
}