firefox不正确的格式错误

Question

我在firefox上遇到ajax请求的情况，我在firebug的网络部分检查firefox的一些请求的类型，响应被识别为xml而不是json，得到一个不正确的格式错误，这个错误不是发生在铬。 我正在使用框架 extJS 并使用 Ext.Ajax.request 方法进行申请。

这里是chrome的标题

POST /stricto/crsCronograma/pesquisa?_dc=1451910851660 HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Content-Length: 678
Pragma: no-cache
Cache-Control: no-cache
Origin: http://localhost:8080
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Accept: */*
Referer: http://localhost:8080/stricto/?id=desenv_Stricto-SA_7018
Accept-Encoding: gzip, deflate
Accept-Language: pt-BR,pt;q=0.8,en-US;q=0.6,en;q=0.4
Cookie: JSESSIONID=95519F96AD70310CE466B2164ED7A08A

和火狐

Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8,application/json
Accept-Language: pt-BR,pt;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Referer: http://localhost:8080/stricto/?id=desenv_Stricto-SA_7018
Content-Length: 678
Cookie: JSESSIONID=5DE7F2C586F125FC590548957B486F43
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

这里是发出请求的代码

 request: (function () {

    /**
     * Normaliza os dados de entrada
     * 
     * @return {Object} config
     */
    function processArgs() {
        var defaults = {
            root: 'data',
            params: {}
        };

        if (Sharedev.util.Object.isString(arguments[0]))
            return Ext.apply(defaults, {
                url: arguments[0]
            }, arguments[1]);

        return Ext.apply(defaults, arguments[0] || {});
    }

    /**
     * Normaliza as funções de success ou failure
     */
    function processCallbacks(config) {
        var onResponseSuccess = config.success;
        var onResponseFailure = config.failure;

        return Ext.apply(config, {
            failure: Sharedev.util.Ajax.onRequestFailure,
            success: Sharedev.util.Ajax.onRequestSuccess,
            onResponseSuccess: onResponseSuccess || Sharedev.util.Ajax.onResponseSuccess,
            onResponseFailure: onResponseFailure || Sharedev.util.Ajax.onResponseFailure
        });
    }

    /**
     * Processa os dados do record
     */
    function processRecord(config) {
        var record;

        if (!(record = config.record || config.data))
            return config;

        delete config.data;
        delete config.record;

        if (record instanceof Ext.data.Model) {
            config.model = record.self;
            Ext.applyIf(config.params, Sharedev.util.Object.addPrefix(record.getData(), Sharedev.util.Class.getSimpleName(config.model, true)));
        } else {
            throw new Sharedev.util.Exception.IllegalArgument('A propriedade "record" esta não é uma instancia de um modelo');
        }

        return config;
    }

    function processModel(config) {
        if (!config.model)
            return;

        var Model = config.model && Sharedev.util.Record.getModel(config.model);

        if (!config.url && Model) {
            var simplename = Sharedev.util.Class.getSimpleName(Model, true);
            config.url = './' + simplename + '/' + Sharedev.data.Proxy.prototype.apiMethod.read;
        }

        Ext.applyIf(config.params, {
            map: Sharedev.util.Ajax.initMapProperty(Model, true)
        });

        return config;
    }

    function processMask(config) {
        if (!config.mask)
            return;

        var callback = config.callback;
        var msg, target;

        if (config.mask.isComponent)
            target = config.mask;
        else {
            target = config.mask.target;
            msg = config.mask.msg;
        }

        Sharedev.util.LoadMask.show(target, msg);
        delete config.mask;

        return Ext.apply(config, {
            $maskTarget: target,
            $callback: callback,
            callback: function (config) {
                Sharedev.util.LoadMask.hide(config.$maskTarget);
                if (config.$callback)
                    config.$callback.apply(this, arguments);
            },
        });
    }

    function processFilters(config) {

        if (!config.filters)
            return;

        Ext.applyIf(config.params, {
            filter: Sharedev.util.Ajax.initFilterProperty(config.filters)
        });

        delete config.filters;
        return config;
    }

    return function () {
        var config = processArgs.apply(this, arguments);
        processCallbacks(config);
        processRecord(config);
        processModel(config);
        processFilters(config);
        processMask(config);

        Sharedev.util.Ajax.format(config.params);
        return Ext.Ajax.request(config);
    };

我在服务器上使用 java，并且在此方法中设置了标头 contntettype

public static void includeJson(Result result, String message) {
    if (result.included().containsKey("message")) {
        return; // so coloca a mensagem uma vez, pois se colocar mais de uma, ira concatenar erroneamente
    }
    result.include("message", message);// adicionado como include somente para verificar se ja foi respondido ou nao

    String contenttype = "application/json";
    if (result.included().containsKey("content-type")) {
        contenttype = (String) result.included().get("content-type");
    }

    result.use(Results.http()).body(message).addHeader("content-type", contenttype);
}

Answer 1

Firefox 正在发送您指定的请求。您没有指定您接受哪种响应类型，Firefox 使用在 about:config network.http.accept.default 中设置的默认响应类型。该默认值表示 Firefox 更喜欢 XML 而不是 JSON (text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8)。如果可以的话，服务器会根据浏览器的请求愉快地为该类型提供服务。

另一方面，Chrome 并没有定义它喜欢什么类型 (*/*)，而 IE 告诉服务器它更喜欢 JSON。因此，虽然您的服务器确实将 JSON 提供给 Chrome，但 .NET 默认情况下会将 XML 提供给 Chrome（和 Firefox，仅将 JSON 发送给 IE）。

长话短说，您要做的是明确定义您可以接受的返回类型：

Ext.Ajax.request({
    ...
    headers:{
        Accept:'application/json'
    }
});

您会看到，一旦设置了 Accept 标头，您就会神奇地获得 JSON 服务，前提是服务器正确识别请求类型并能够提供 JSON。