1. Análise de abertura
Primeiro de tudo, todos devem estar familiarizados com o conceito de "http". Não se baseia em um idioma específico, mas é um protocolo de camada de aplicativo geral. Diferentes idiomas têm detalhes de implementação diferentes, mas são consistentes com seus princípios e as idéias são as mesmas.
Como um ambiente de execução do host, o NodeJS usa o JavaScript como idioma host e também possui seu próprio conjunto de padrões implementados. Neste artigo, vamos aprender sobre o "módulo HTTP" juntos. Mas como premissa,
Espero que você possa ler a API fornecida pelo site oficial primeiro e ter um entendimento preliminar, o que a tornará muito mais conveniente. A seguir, é apresentada uma visão geral da API na parte HTTP:
A cópia do código é a seguinte:
Http
http.status_codes
http.createServer ([RequestListener])
http.createclient ([port], [host])
Classe: http.server
Evento: 'Solicitação'
Evento: 'conexão'
Evento: 'Fechar'
Evento: 'CheckContinue'
Evento: 'Connect'
Evento: 'Upgrade'
Evento: 'ClientError'
Server.Listen (Port, [HostName], [backlog], [retorno de chamada])
Server.Listen (Path, [retorno de chamada])
Server.Listen (Handle, [retorno de chamada])
Server.close ([retorno de chamada])
Server.MaxHeaderCount
Server.setTimeout (MSECS, retorno de chamada)
Server.Timeout
Classe: http.ServerResponse
Evento: 'Fechar'
Response.WritEContinue ()
Response.WriteHead (StatusCode, [Reasonfrase], [cabeçalhos])
Response.setTimeout (MSECS, retorno de chamada)
Response.statuscode
Response.setheader (nome, valor)
Response.HeaderSsent
Response.senddate
Response.getheader (nome)
Response.RemoveHeader (nome)
Response.Write (Chunk, [codificação])
Response.Addtrailers (cabeçalhos)
Response.end ([Data], [codificação])
http.request (opções, retorno de chamada)
http.get (opções, retorno de chamada)
Classe: http.agent
Novo agente ([opções])
Agent.MaxSockets
Agent.MaxFreesockets
agente.sockets
Agent.Freesockets
Agent.Requests
Agent.Destroy ()
Agent.getName (Opções)
http.globalagent
Classe: http.clientRequest
Evento 'Resposta'
Evento: 'soquete'
Evento: 'Connect'
Evento: 'Upgrade'
Evento: 'Continue'
request.write (chunk, [codificação])
request.end ([Data], [codificação])
request.abort ()
request.setTimeout (Timeout, [retorno de chamada])
request.setNodelay ([Nodelay])
request.SetSocketkeeepalive ([Enable], [InitialDelay])
http.incomingMessage
Evento: 'Fechar'
message.httpversion
Message.Headers
message.rawheaders
Message.Tailers
message.rawtrailers
message.setTimeout (msecs, retorno de chamada)
message.method
message.url
message.statuscode
message.socket
Vamos começar com um exemplo simples, criar um arquivo chamado Server.js e escrever o seguinte código:
A cópia do código é a seguinte:
var http = requer ('http');
var server = http.createServer (function (req, res) {
Res.WriteHeader (200, {
'Content-type': 'text/plana; charset = utf-8' // add charset = utf-8
});
res.nd ("Olá, grande urso!");
});
Server.Listen (8888);
console.log ("servidor http em execução na porta 8888 ...");
(Node Server.js) A seguir, é apresentado o resultado em execução:
2. Exemplos de análise detalhados
Vamos dar uma olhada neste pequeno exemplo:
(linha 1): Apresente o módulo "http" que vem com o NodeJS através do "requer" e atribua -o à variável HTTP.
(2 linhas): Chame a função fornecida pelo módulo HTTP: "CreateServer". Esta função retorna um novo objeto de servidor da web.
O parâmetro "requestListener" é uma função que será adicionada automaticamente à fila de escuta do evento "Solicitação".
Quando chegar a uma solicitação, o loop de eventos coloca a função de retorno de chamada do ouvinte na fila de execução, e todo o código no nó é executado um por um da fila de execução.
Essas execuções estão todas no encadeamento do trabalhador (o loop de eventos em si pode ser considerado como estando em um encadeamento independente. Geralmente não mencionamos esse thread, mas ligue para o nó de um ambiente de execução de thread único).
Todos os retornos de chamada são executados em um tópico de trabalhador.
Vamos dar uma olhada na função de retorno de chamada "requestListener", que fornece dois parâmetros (solicitação, resposta).
Acionado toda vez que uma solicitação é recebida. Observe que cada conexão pode ter várias solicitações (em conexões de manutenção).
"Solicitação" é uma instância de http.incomingMessage. "Response" é uma instância de http.ServerResponse.
Um objeto de solicitação HTTP é um fluxo legível, enquanto um objeto de resposta HTTP é um fluxo gravável.
Um objeto "IndomingMessage" é criado pelo http.server ou http.clientRequest.
E passe como o primeiro parâmetro para os eventos "Solicitação" e "Resposta", respectivamente.
Também pode ser usado para acessar o estado, arquivos de cabeçalho e dados da resposta.
Ele implementa a interface "fluxo", bem como os seguintes eventos, métodos e propriedades adicionais. (Consulte a API para obter detalhes).
(3 linhas): "WriteHeader", use a função "Response.WriteHead ()" para enviar um status HTTP 200 e o tipo de conteúdo do cabeçalho HTTP (tipo conteúdo).
Responda ao cabeçalho da solicitação. "StatusCode" é um código de status HTTP de três bits, como 404. O último parâmetro, "cabeçalhos", é o conteúdo do cabeçalho da resposta.
Pegue uma castanha:
A cópia do código é a seguinte:
var corpo = 'olá mundo';
Response.writehead (200, {
'Length-' Length ': Body.length,
'Tipo de conteúdo': 'texto/simples'
});
Nota: O comprimento do conteúdo é calculado em bytes, não em caracteres.
O motivo do exemplo anterior é que a string "Hello World!" Contém apenas caracteres de byte único.
Se o corpo contiver caracteres codificados por multibyte, o buffer.byTeLength () deve ser usado para determinar o número de bytes da sequência no caso de codificação de caracteres multibyte.
Deve-se explicar ainda que o nó não verifica se o atributo-lenth de conteúdo corresponde ao comprimento do corpo transmitido.
StatusCode é um código de status HTTP de três bits, por exemplo: "404". O que eu quero falar aqui é "http.status_codes", todos os conjuntos e descrições curtas dos códigos de status de resposta "http" padrão estão incluídos.
A seguir, a referência do código -fonte:
A cópia do código é a seguinte:
var staty_codes = exports.status_codes = {
100: 'continue',
101: 'Protocolos de comutação',
102: 'Processamento', // RFC 2518, obsoleto pela RFC 4918
200: 'ok',
201: 'criado',
202: 'aceito',
203: 'Informações não autoritativas',
204: 'sem conteúdo',
205: 'Reset Content',
206: 'Conteúdo parcial',
207: 'Multi-status', // RFC 4918
300: 'múltiplas opções',
301: 'movido permanentemente',
302: 'movido temporariamente',
303: 'Veja outros',
304: 'não modificado',
305: 'Use Proxy',
307: 'redirecionamento temporário',
400: 'Bad Solicy',
401: 'não autorizado',
402: 'Pagamento necessário',
403: 'proibido',
404: 'não encontrado',
405: 'Método não permitido',
406: 'não aceitável',
407: 'Autenticação de proxy necessária',
408: 'Solicitar tempo limite',
409: 'conflito',
410: 'Gone',
411: 'comprimento necessário',
412: 'Falha na pré -condição',
413: 'solicitar entidade muito grande',
414: 'request-uri muito grande',
415: 'Tipo de mídia não suportado',
416: 'Solicitado intervalo não satisfatório',
417: 'Expectativa falhou',
418: 'i/' ma tule ', // rfc 2324
422: 'entidade não processável', // RFC 4918
423: 'Locked', // RFC 4918
424: 'Falha na dependência', // RFC 4918
425: 'Coleção não ordenada', // RFC 4918
426: 'Atualização necessária', // RFC 2817
500: 'Erro do servidor interno',
501: 'não implementado',
502 Bad Gateway',
503: 'serviço indisponível',
504: 'Time-out de gateway',
505: 'versão http não suportada',
506: 'Variante também negocia', // RFC 2295
507: 'armazenamento insuficiente', // RFC 4918
509: 'Limite de largura de banda excedido',
510: 'não estendido' // RFC 2774
};
Extraído do código -fonte NodeJS "http.js" começa com a linha 143.
De fato, não é difícil ver do resultado da resposta do cliente:
(6 linhas): "Response.end" ------ Quando todos os cabeçalhos e mensagens de resposta são enviados, esse método envia o sinal para o servidor. O servidor pensará que a mensagem é concluída.
Este método deve ser chamado após a conclusão de cada resposta. Se o parâmetro "Data" for especificado, será equivalente a chamar "Response.Write (Data, Coding)" primeiro e depois chamando "Respons.end ()".
(8 linhas): "Server.Listen (8888)" ----- O servidor aceita conexões com o identificador especificado e se liga a uma porta específica.
O exposto acima é um processo de análise mais detalhado, na esperança de ajudar a aprofundar a compreensão. Embora não haja muito código, o foco é entender alguns mecanismos detalhados, para que os aplicativos NODEJS possam ser desenvolvidos com eficiência no futuro.
Três, exemplos
Além de usar o objeto "Solicitação" para acessar os dados do cabeçalho da solicitação, o objeto "Solicitação" também pode ser usado como um fluxo de dados somente leitura para acessar os dados do corpo da solicitação.
Aqui está um exemplo de uma solicitação de "post":
A cópia do código é a seguinte:
http.createServer (função (solicitação, resposta) {
var corpo = [];
console.log (request.method);
console.log (request.Headers);
request.on ('dados', função (chunk) {
body.push (pedaço);
});
request.on ('end', function () {
corpo = buffer.concat (corpo);
console.log (body.toString ());
});
}). Ouça (8888);
Abaixo está um conteúdo completo de dados de solicitação "HTTP".
A cópia do código é a seguinte:
POST/HTTP/1.1
Agente de usuário: CURL/7.26.0
Anfitrião: localhost
Aceitar: */*
Comprimento de conteúdo: 11
Tipo de conteúdo: aplicativo/x-www-forma-urlncoded
Olá mundo
Quatro, vamos resumir
(1) Entenda o conceito de "http".
(2) Proficiente no uso de APIs relacionadas a "http".
(3) Preste atenção ao controle dos detalhes, como: os detalhes do processamento entre "Post, Get".
(4), Compreensão de "RequestListener".
(5), enfatize um conceito: um objeto de solicitação HTTP é um fluxo legível, enquanto um objeto de resposta HTTP é um fluxo gravável.