Qual é o tipo de conteúdo JSON correto?

Estou brincando com o JSON há algum tempo, apenas enviando-o como texto e não machucou ninguém (que eu saiba), mas eu gostaria de começar a fazer as coisas corretamente.

Eu vi assim que muitos "padrões" supostamente para o tipo de conteúdo JSON:

application/json
application/x-javascript
text/javascript
text/x-javascript
text/x-json

Mas qual é a correta ou melhor? Entendo que há problemas de segurança e suporte ao navegador que variam entre eles.

Sei que há uma pergunta semelhante: que tipo MIME se JSON está sendo retornado por uma API REST? , mas eu gostaria de uma resposta um pouco mais direcionada.

Para texto JSON:

application/json

O tipo de mídia MIME para o texto JSON é application/json. A codificação padrão é UTF-8. (Fonte: RFC 4627 ).

Para JSONP (javascript executável) com retorno de chamada:

application/javascript

Aqui estão algumas postagens do blog que foram mencionadas nos comentários relevantes.

• Por que você não deve usar o text/htmlJSON
• O Internet Explorer às vezes tem problemas com application/json
• Uma lista bastante completa de Mimetypes e para que usá-los
• A lista oficial de tipos de mímica na IANA da resposta de @ gnrfan abaixo

A IANA registrou o tipo MIME oficial para JSON como application/json.

Quando perguntado por que não text/json, Crockford parece ter dito que o JSON não é realmente JavaScript nem texto, e que a IANA tem maior probabilidade de distribuir do application/*que text/*.

Mais recursos:

• Tipos de mídia
• Solicitação de comentários 4627
• bluesmoon: JSON tem um tipo

Para JSON:

Content-Type: application/json

Para JSON-P :

Content-Type: application/javascript

Obviamente, o tipo de mídia MIME correto para JSON é application/json, mas é necessário perceber que tipo de dados é esperado em seu aplicativo.

Por exemplo, eu uso o Ext GWT e a resposta do servidor deve ser em texto / html, mas contém dados JSON.

Lado do cliente, ouvinte de formulário Ext GWT

uploadForm.getForm().addListener(new FormListenerAdapter()
{
    @Override
    public void onActionFailed(Form form, int httpStatus, String responseText) 
    {
        MessageBox.alert("Error");
    }

    @Override
    public void onActionComplete(Form form, int httpStatus, String responseText) 
    {
        MessageBox.alert("Success");
    }
});

No caso de usar o tipo de resposta application / json , o navegador sugere que eu salve o arquivo.

Fragmento de código-fonte do servidor usando o Spring MVC

return new AbstractUrlBasedView() 
{
    @SuppressWarnings("unchecked")
    @Override
    protected void renderMergedOutputModel(Map model, HttpServletRequest request,
                                           HttpServletResponse response) throws Exception 
    {
        response.setContentType("text/html");
        response.getWriter().write(json);
    }
};

JSON:

A resposta são dados gerados dinamicamente, de acordo com os parâmetros de consulta passados ​​no URL.

Exemplo:

{ "Name": "Foo", "Id": 1234, "Rank": 7 }

Tipo de conteúdo: application/json

JSON-P:

JSON com preenchimento. A resposta são dados JSON, com uma chamada de função envolvida.

Exemplo:

functionCall({"Name": "Foo", "Id": 1234, "Rank": 7});

Tipo de conteúdo: application/javascript

Se você estiver usando o Ubuntu ou o Debian e forneça arquivos .json através do Apache, convém servir os arquivos com o tipo de conteúdo correto. Estou fazendo isso principalmente porque quero usar a extensão JSONView do Firefox

O módulo Apache mod_mime ajudará a fazer isso facilmente. No entanto, com o Ubuntu, você precisa editar o arquivo /etc/mime.types e adicionar a linha

application/json json

Em seguida, reinicie o Apache:

sudo service apache2 restart

Se você estiver chamando o ASP.NET Web Services do lado do cliente, precisará usar application/jsonpara que ele funcione. Eu acredito que isso é o mesmo para as estruturas jQuery e Ext .

O tipo de conteúdo certo para JSON é, a application/jsonmenos que você esteja usando JSONP , também conhecido como JSON com preenchimento, que na verdade é JavaScript e, portanto, seria o tipo de conteúdo certo application/javascript.

Não há dúvida de que application/jsoné o melhor MIME tipo para uma resposta JSON.

Mas tive alguma experiência em que tive que usar application/x-javascriptdevido a alguns problemas de compactação. Meu ambiente de hospedagem é uma hospedagem compartilhada com o GoDaddy . Eles não me permitem alterar as configurações do servidor. Eu adicionei o seguinte código ao meu web.configarquivo para compactar respostas.

<httpCompression>
    <scheme name="gzip" dll="%Windir%\system32\inetsrv\gzip.dll"/>
    <dynamicTypes>
        <add mimeType="text/*" enabled="true"/>
        <add mimeType="message/*" enabled="true"/>
        <add mimeType="application/javascript" enabled="true"/>
        <add mimeType="*/*" enabled="false"/>
    </dynamicTypes>
    <staticTypes>
        <add mimeType="text/*" enabled="true"/>
        <add mimeType="message/*" enabled="true"/>
        <add mimeType="application/javascript" enabled="true"/>
        <add mimeType="*/*" enabled="false"/>
    </staticTypes>
</httpCompression>
<urlCompression doStaticCompression="true" doDynamicCompression="true"/>

Ao usar isso, as páginas .aspx foram compactadas com g-zip, mas as respostas JSON não. Eu adicionei

<add mimeType="application/json" enabled="true"/>

nas seções de tipos estático e dinâmico. Mas isso não compacta as respostas JSON.

Depois disso, removi esse tipo recém-adicionado e adicionei

<add mimeType="application/x-javascript" enabled="true"/>

nas seções de tipos estático e dinâmico e alterou o tipo de resposta em

.ashx (manipulador assíncrono) para

application/x-javascript

E agora descobri que minhas respostas JSON foram compactadas com g-zip. Então, eu pessoalmente recomendo usar

application/x-javascript

somente se você deseja compactar suas respostas JSON em um ambiente de hospedagem compartilhado . Como na hospedagem compartilhada, eles não permitem alterar as configurações do IIS .

Somente ao usar application/jsoncomo o tipo MIME , tenho o seguinte (a partir de novembro de 2011 com as versões mais recentes do Chrome, Firefox com Firebug ):

• Não há mais avisos do Chrome quando o JSON é carregado no servidor.
• O Firebug adicionará uma guia à resposta, mostrando os dados JSON formatados. Se o tipo MIME for diferente, ele aparecerá como 'Conteúdo da resposta'.

Nem tudo funciona para o tipo de conteúdo application/json.

Se você estiver usando o envio de formulário Ext JS para fazer upload do arquivo, esteja ciente de que a resposta do servidor é analisada pelo navegador para criar o documento para <iframe>.

Se o servidor estiver usando JSON para enviar o objeto de retorno, o Content-Typecabeçalho deverá ser definido comotext/html solicitar ao navegador que insira o texto inalterado no corpo do documento.

Consulte a documentação da API Ext JS 3.4.0 .

JSON é uma linguagem específica de domínio (DSL) e um formato de dados independente do JavaScript e, como tal, possui seu próprio tipo MIMEapplication/json . Obviamente, o respeito pelos tipos MIME é direcionado ao cliente, o que text/plainpode acontecer com a transferência de bytes, mas você pressionaria desnecessariamente a interpretação para o domínio do aplicativo do fornecedor - application/json. Você transfere XML via text/plain?

Mas, honestamente, sua escolha do tipo MIME é aconselhar o cliente sobre como interpretar os dados - text/plainou text/HTML(quando não é HTML) é como apagar o tipo - é tão pouco informativo quanto transformar todos os seus objetos do tipo Object em uma linguagem digitada.

Nenhum tempo de execução do navegador que eu conheça pegará um documento JSON e o disponibilizará automaticamente para o tempo de execução como um objeto acessível por JavaScript sem intervenção, mas se você estiver trabalhando com um cliente com problemas, isso é uma questão totalmente diferente. Mas essa não é a história toda - os serviços JSON RESTful geralmente não têm tempos de execução do JavaScript, mas não os impedem de usar o JSON como um formato viável de intercâmbio de dados. Se os clientes são tão aleijados ... então eu consideraria talvez a injeção de HTML por meio de um serviço de modelagem do Ajax .

Aplicação / JSON!

Se você estiver em um ambiente do lado do cliente, é obrigatório investigar sobre o suporte a vários navegadores para um aplicativo Web bem suportado.

O tipo de conteúdo HTTP correto seria application/json, como outros já destacados, mas alguns clientes não lidam muito bem com isso, é por isso que o jQuery recomenda o padrão text/html.

A resposta correta é:

Content-Type: application/json

Como muitos outros mencionaram, application/json é a resposta correta.

Mas o que ainda não foi explicado é o que significam as outras opções que você propôs.

• application/x-javascript: O tipo experimental MIME para JavaScript antes application/javascriptera padronizado.

• text/javascript: Agora obsoleto. Você deve usar application/javascriptao usar javascript.

• text/x-javascript: Tipo experimental MIME para a situação acima.

• text/x-json: Tipo experimental de MIME para JSON antes de application/jsonser oficialmente registrado.

Em suma, sempre que você tiver alguma dúvida sobre os tipos de conteúdo, verifique este link

No JSP , você pode usar isso na diretiva de página:

<%@ page language="java" contentType="application/json; charset=UTF-8"
    pageEncoding="UTF-8"%>

O tipo de mídia MIME correto para JSON é application/json. O JSP o utilizará para enviar uma resposta ao cliente.

" application/json" É o tipo de conteúdo JSON correto.

def ajaxFindSystems = {
  def result = Systems.list()
  render(contentType:'application/json') {
    results {
      result.each{sys->
        system(id:sys.id, name:sys.name)
      }
    }
    resultset (rows:result.size())
  }
}

O registro IANA paraapplication/json diz

Aplicativos que usam esse tipo de mídia: JSON foi usado para trocar dados entre aplicativos escritos em todas as linguagens de programação: ActionScript, C, C #, Clojure, ColdFusion, Common Lisp, E, Erlang, Go, Java, JavaScript, Lua, Objective CAML, Perl, PHP, Python, Rebol, Ruby, Scala e Esquema.

Você notará que o IANA.org não lista nenhum desses outros tipos de mídia , na verdade até application/javascriptagora está obsoleto. Então application/jsoné realmente a única possível correta resposta .

O suporte ao navegador é outra coisa.

Os tipos de mídia não padrão mais amplamente suportados são text/jsonou text/javascript. Mas alguns grandes nomes até usam text/plain.

Ainda mais estranho é o cabeçalho Content-Type enviado pelo Flickr, que retorna JSON como text/xml. O Google usa text/javascriptpara algumas das suas APIs do Ajax.

Exemplos:

curl -I "https://ajax.googleapis.com/ajax/services/search/video?v=1.0&q=jsonexample"

Resultado: Content-Type: text/javascript

curl -I "https://www.flickr.com/services/rest/?method=flickr.test.echo&format=json&api_key=f82254c1491d894f1204d8408f645a93"

Resultado: Content-Type: text/xml

O tipo MIME certo é application/json

MAS

Eu experimentei muitas situações em que o tipo de navegador ou o usuário da estrutura precisava:

text/html

application/javascript

Eu uso o abaixo

contentType: 'application/json',
data: JSON.stringify(SendData),

O cabeçalho Content-Type deve ser definido como ' application / json ' ao postar. O servidor que atende a solicitação deve incluir " Accept = application / json ". No Spring MVC, você pode fazer o seguinte:

@RequestMapping(value="location", method = RequestMethod.POST, headers = "Accept=application/json")

Adicione cabeçalhos à resposta:

HttpHeaders headers = new HttpHeaders();
headers.add("Content-Type", "application/json");

No Spring, você tem um tipo definido: MediaType.APPLICATION_JSON_VALUEque é equivalente a application / json .

Os application/jsontrabalhos grandes em PHP para armazenar um array ou objeto de dados.

Eu uso esse código para colocar dados em JSON no Google Cloud Storage (GCS), definido publicamente :

$context = stream_context_create([
    'gs' => [
        'acl'=>'public-read', 
        'Content-Type' => 'application/json',
    ]
]);

file_put_contents(
    "gs://BUCKETNAME/FILENAME.json", 
    json_encode((object) $array), 
    false, 
    $context
);

Para voltar, os dados são simples:

$data = json_decode(file_get_contents("gs://BUCKETNAME/FILENAME.json"));

Se o JSON estiver com preenchimento, será application/jsonp. Se o JSON estiver sem preenchimento, seráapplication/json .

Para lidar com ambos, é uma boa prática usar: 'application / javascript' sem se preocupar se é com preenchimento ou sem preenchimento.

Para JSON, estou usando:

 Content-Type: application/json

Isso é descrito na proposta JSON Data Interchange Format 7158 da IETF, seção 1.2: Especificações do JSON .

Estendendo as respostas aceitas, quando você estiver usando JSON em um contexto REST ...

Há um forte argumento sobre o uso application/x-resource+jsone application/x-collection+jsonquando você está representando recursos e coleções REST.

E se você decidir seguir a especificação jsonapi , deverá usar application/vnd.api+json, conforme documentado.

Embora não haja um padrão universal, é claro que a semântica adicionada aos recursos transferidos justifica um Tipo de Conteúdo mais explícito do que apenasapplication/json .

Seguindo esse raciocínio, outros contextos poderiam justificar um tipo de conteúdo mais específico .

Os desenvolvedores de PHP usam isso:

<?php
    header("Content-type: application/json");

    // Do something here...
?>

Se você obtiver dados da API REST em JSON, precisará usar o tipo de conteúdo

For JSON data: Content-Type:application/json
For HTML data: Content-Type:text/html,
For XHTML data: Content-Type:application/xhtml+xml,
For XML data: Content-Type:text/xml, application/xml

Content-Type: application/json- json
Content-Type: application/javascript- json-P
Content-Type: application/x-javascript- javascript
Content-Type: text/javascript- javascript MAS obsoletas, versões mais antigas do IE costumavam usar como atributo html.
Content-Type: text/x-javascript- Tipos de mídia JavaScript MAS obsoletos
Content-Type: text/x-json- json antes do aplicativo / json ser registrado oficialmente.

Os formatos JSON (JavaScript Object Notation) e JSONP ("JSON com preenchimento") parecem ser muito semelhantes e, portanto, pode ser muito confuso qual tipo MIME eles devem usar. Mesmo que os formatos sejam semelhantes, existem algumas diferenças sutis entre eles.

Portanto, sempre que tiver alguma dúvida, tenho uma abordagem muito simples (que funciona perfeitamente bem na maioria dos casos), a saber, vá e verifique o documento RFC correspondente.

JSON RFC 4627 (O tipo de mídia application / json para JavaScript Object Notation (JSON)) é uma especificação do formato JSON. Diz na seção 6, que o tipo de mídia MIME para o texto JSON é

application/json.

JSONP JSONP ("JSON com preenchimento") é tratado de maneira diferente da JSON, em um navegador. O JSONP é tratado como um script JavaScript regular e, portanto, deve usar application/javascript,o tipo MIME oficial atual para JavaScript. Em muitos casos, no entanto, o text/javascripttipo MIME também funcionará bem.

Observe que text/javascriptfoi marcado como obsoleto pelo documento RFC 4329 (tipos de mídia de script) e é recomendável usar o application/javascripttipo. No entanto, devido a motivos herdados, text/javascriptainda é amplamente utilizado e possui suporte para vários navegadores (o que nem sempre é o caso do application/javascripttipo MIME, especialmente em navegadores mais antigos).