[MÚSICA]
Neste exercício, vamos explorar alguns dos módulos de nó de código.
Em particular, vamos olhar para o módulo HTTP que é construído em Node e
usar o módulo HTTP para configurar e iniciar um servidor web simples.
Vamos também olhar para como podemos servir arquivos estáticos do nosso servidor HTTP Node.
Nós também vamos olhar para esse módulo de sistema de arquivos e o módulo de caminho e
como eles podem nos ajudar a servir arquivos estáticos em nosso servidor HTTP baseado em nós.
Então vamos explorar alguns dos módulos de nó de código neste exercício.
Para começar com este exercício, vá para um local conveniente no seu computador.
Então, vamos para a pasta NodeJS que já criamos em um
dos exercícios anteriores.
E na pasta NodeJS, vou criar uma nova pasta chamada node-http.
E, em seguida, vamos configurar isso como um aplicativo Node.
Além disso, movendo-se para a pasta node-http,
vamos criar uma sub-pasta lá chamada public que vai continuar
alguns dos arquivos html que vamos servidor a partir de nosso aplicativo Node HTTP.
Agora movendo-se para um terminal, navegue até o nó,
pasta -http.
E vamos inicializar esta pasta para estar em nosso aplicativo.
Então vamos começar com npm init e
inicializar esse pacote para o nosso arquivo JSON aqui.
E, em seguida, vamos dar o nome do pacote como node-http e
aceitar a versão padrão,
ea descrição é Node Exemplo de Módulo HTTP.
E o ponto de partida é index.js, nenhum comando test,
nenhum repositório git para o momento, e autor,
digite seu nome e aceite o resto como está.
E isso deve criar o pacote para um arquivo de manifesto JSON.
Agora vamos abrir este projeto em nosso editor favorito.
Então deixe-me iniciar o meu código do Visual Studio nesta pasta.
E no código do Visual Studio, vamos para o pacote para o nosso arquivo JSON.
E, em seguida, vamos adicionar em outro script para o pacote,
para o nosso arquivo JSON chamado start e
que iria executar índice nó.
E lembre-se de colocar uma vírgula após o engate do teste.
E salve as alterações no arquivo package.json.
Agora em que Project,
crie um novo arquivo chamado index.js.
Vamos configurar este index.js para usar o módulo Nó HTTP.
Então, neste arquivo, vamos digitar const
http = require (“http”).
Então você pode ver que estamos usando o módulo de código HTTP, e
estamos exigindo isso simplesmente especificando o nome do módulo de código HTTP lá.
Além disso, vamos declarar,
Um par de constantes aqui e, em seguida,
Vamos chamar hostname e
o número da porta como 3000 por padrão.
Agora vamos configurar o servidor.
Para configurar o servidor, vamos dizer servidor const = http.
O módulo HTTP suporta um método chamado CreateServer,
então eles vão usar o método CreateServer sobre isso.
Este método CreateServer terá uma função como um parâmetro e
esta função leva dois
valores como parâmetros, solicitação e resposta.
E como você pode ver, estou escrevendo uma função de seta aqui.
Assim, a solicitação e resposta são os dois parâmetros para a função que fornecemos
como um parâmetro para o método CreateServer aqui.
E dentro disso, diremos
console.log (req.headers).
Então, aqui, o req e res são a solicitação HTTP de entrada para o servidor.
E eles tipo de geração de objeto de resposta que vai
ser construído por este servidor e retornado para o cliente
que se conecta a este servidor HTTP que estamos criando aqui.
Então a solicitação é a solicitação de entrada de qualquer navegador ou
de qualquer lugar que está tentando acessar este servidor que vamos iniciar
usando este aplicativo de nó HTTP que estamos desenvolvendo aqui.
Assim, a partir da
solicitação, o objeto request nos dá acesso aos cabeçalhos na solicitação HTTP de entrada.
Então eu vou registrar
os cabeçalhos de entrada da solicitação HTTP entrando usando este console.log.
Só para minha informação, só para saber de onde vem este pedido.
Depois disso, podemos construir a resposta usando o res e
isso nos fornecerá um método chamado StatusCode.
O StatusCode nos permitirá configurar o StatusCode para a mensagem de resposta.
Então, neste caso, vou configurar o StatusCode como 200.
Se você se lembrar da discussão anterior sobre os fundamentos de rede,
você saberá que StatusCode de 200 significa que tudo está bem.
E assim, nós configuramos o código de status aqui para a mensagem de resposta e
, em seguida, vamos também configurar o cabeçalho para a mensagem de resposta.
E um dos temores de cabeçalho que vamos
configurar é chamado Content-Type.
E o Content-Type,
vamos especificar isso para ser 'text/html'.
Assim, o corpo de resposta irá conter os dados na forma de html aqui.
Portanto, o cabeçalho é configurado para informar o cliente que você está enviando
na resposta e o corpo é formatado no formato html.
E então, finalmente, vamos dizer res.end ('').
Então isso termina a resposta aqui, e quando isso for feito,
essa informação será enviada de volta para o cliente.
Então aqui, deixe-me apenas construir uma página html in-line aqui,
então eu vou dizer <Olá,
Mundo! .
E feche a tag h1, a tag body
e a tag html, bem ali.
E essa é uma resposta HTML válida que pode
ser enviada de volta do nosso servidor aqui.
Então este servidor, como você espera simplesmente vai enviar um Olá mundo para o cliente.
Então, agora que configuramos o servidor, precisamos iniciar este servidor.
Para iniciar este servidor em nota,
precisamos dizer server.listen.
E isso iniciará a porta de escuta na qual o servidor escutará
solicitações recebidas.
E isso seria iniciado no número da porta dado o meu porto,
que nós já configuramos aqui no porto const.
E o segundo parâmetro é o nome do host que já configuramos anteriormente.
E o terceiro parâmetro é uma função que será
executada quando o servidor for iniciado.
Nesta função, basta ir para imprimir as informações sobre o servidor.
Então, aqui eu vou apenas dizer console.log.
E no console.log,
eu vou imprimir as informações para que eu vou usar uma citação traseira.
Portanto, note o uso de aspas não a cotação normal.
A razão pela qual estamos usando isso é porque nós vamos estar usando
algumas variáveis dentro da string que estamos indo para construir aqui.
Então, vamos dizer servidor em execução em http://.
E, em seguida, vamos dizer $ e
, em seguida, nome do host.
Lembre-se que este nome de host, você já declarou anteriormente.
E, em seguida, a segunda parte,
vamos dizer: $ e porto.
Portanto, esses dois valores serão substituídos pelos valores correspondentes.
E já que estamos encerrando isso entre aspas.
E se você incluir algo dentro dos aumentos do dólar,
que será substituído por seu valor nesta string aqui.
É isso.
Temos um servidor HTTP simples em funcionamento.
Então, vamos salvar as alterações para isso.
E vamos começar nosso aplicativo e ver o que ele serve.
Indo para o terminal, vamos digitar npm start, e
isso deve iniciar nosso aplicativo.
E notamos que ele imprime nosso dizendo que o servidor
em execução em http://localhost:3000.
Agora você pode acessar este URL digitando-o na barra de endereço de qualquer navegador.
Então deixe-me iniciar uma janela do navegador Chrome e, em seguida, digite isso e
ver o que o servidor retornará.
Iniciando uma nova janela.
Deixe-me apenas digitar http://
localhost:3000.
E isso deve retornar um Hello World como esperamos.
Agora, quando vamos para o console você vê que no console há
detalhes do cabeçalho solicitações de entrada é impresso aqui.
Algumas coisas são muito fáceis de localizar aqui.
Então este é o host, localhost: 3000, e você também vê que o “user-agent”
está definido como “Chrome” aqui, a versão do Chrome que estou usando aqui.
Então essa é uma ilustração interessante da mensagem de solicitação HTTP.
E o que está contido no cabeçalho da mensagem de solicitação que veio aqui.
É tão interessante observar o que o seu sever está
imprimindo na tela aqui.
Com isso, completamos a primeira metade deste exercício.
Agora podemos inicializar este aplicativo em um repositório Git
e, em seguida, salvar as alterações para o repositório Git.
Então vamos em frente e fazer isso a seguir.
No tipo de prompt, get init e que inicializou o repositório.
E então vamos dizer status git e você vê que esses dois arquivos são novos.
Então vamos dizer git add.
E fazer git commit
-m “Node HTTP Exemplo 1".
E, em seguida, verifique isso em nosso repositório Git.
Agora mais uma ferramenta que é muito útil
quando estamos olhando para aplicativos do lado do servidor é chamado Postman.
Agora Postman vem na forma de uma extensão do navegador Chrome ou de
uma ferramenta autônoma que você pode baixar e instalar em seu computador.
Então, para fazer isso, em nosso navegador vamos digitar http.
getpostman.com.
E então é aqui que você pode obter a
ferramenta Postman para o seu sistema operacional específico e instalá-lo.
A ferramenta Postman permite criar solicitações HTTP e, em seguida, enviá-las.
Além disso, ele também oferece a flexibilidade de configurar os cabeçalhos para
sua solicitação HTTP antes de enviá-la.
E então, quando a resposta voltar, você será capaz de examinar a resposta
incluindo os cabeçalhos da resposta que vem do lado do servidor.
Então acho que o Carteiro é muito útil.
Existem algumas outras ferramentas como esta,
mas o Carteiro parece ser o melhor do mercado no momento.
Então eu vou fazer uso do Carteiro através do resto deste curso.
Se você não quiser instalá-lo,
você também pode instalar a extensão do navegador Chrome do Postman e usá-lo.
Vou baixar a versão do Postman para macOS e
depois instalá-la na minha máquina e depois fazer uso dela.
Depois de ter o Postman, a versão autônoma ou
a extensão do navegador Chrome instalada, você poderá iniciá-lo.
E você verá que a interface do usuário é mais ou menos a mesma para
a versão padrão e também para a extensão do navegador Chrome.
E uma vez que você tenha o Postman funcionando,
digite na caixa URL de solicitação,
localhost: 3000.
E envie o pedido para si mesmo.
Certifique-se de que o servidor HTTP do nó está ativo e em execução.
Então, quando você envia a solicitação,
você obteria imediatamente uma resposta do servidor com o código HTML aqui.
Agora, a vantagem, como você vê,
com o uso do Postman é que você pode ver o corpo real da mensagem.
Você também pode olhar para os cabeçalhos para ver o que foi enviado de volta do servidor.
Você também pode configurar muitos detalhes no Postman quando estiver enviando.
Pedido do servidor.
Agora, muitos desses podem não ser muito fáceis de fazer usando uma janela padrão do navegador.
Então essa é a razão pela qual eu prefiro usar [INAUDIBLE] para
gerar as solicitações HTTP para o meu servidor.
E, em seguida, observando a resposta que vem de volta do lado do servidor.
Observe também que ele mostra o código de status aqui e algumas outras informações sobre
a solicitação e o tempo de resposta do lado do servidor.
Agora que criamos seu servidor HTTP baseado em nó simples,
vamos estender ainda mais, vamos criar alguns arquivos HTML na pasta pública.
Vamos chamá-lo assim como index.html.
E, em seguida, também aboutus.html,
e, em seguida, apenas incluir algumas informações sobre ossos nuos aqui.
Então, vamos dizer html, e
título como Este é index.html.
E, em seguida, vamos digitar o corpo da página html.
Diga h1 Index.html e
o corpo e, em seguida, este é
o conteúdo deste arquivo.
Alguns código html básico aqui, deixe-me copiar isso e, em
seguida, colar também na página aboutus.html.
E o conteúdo do arquivo aboutus.html, é isso.
Acabamos de criar duas páginas HTML, e
estas são páginas HTML estáticas que criamos na pasta pública.
Agora, podemos configurar nosso servidor HTTP nó para ser capaz de servir páginas estáticas?
Então isso é o que vamos configurar na segunda parte deste exercício.
Então, voltando para o arquivo index.js,
além do módulo de código HTTP,
eu também vou importar o módulo de código do sistema de arquivos.
E esse módulo de código de caminho.
O caminho permite que você especifique a parte de um arquivo em seu sistema de arquivos local.
O módulo do sistema de arquivos permite ler e
gravar arquivos do sistema de arquivos local.
Então, com isso, eles vão dizer servidor constante, HTTP.CreateServer.
Para o log do console, em vez de digitar cabeçalhos de solicitação inteiros,
vou simplesmente digitar apenas informações suficientes, então
eu vou dizer, Solicitar,
Apenas a URL dessa solicitação.
Por método.
Portanto, o método seria obter postagem de porta ou excluir métodos.
Então isso registrará essa informação.
Agora, o que vamos fazer é em vez de enviar
esta resposta, a resposta padrão Olá Mundo.
Aqui, vamos examinar o método e,
em seguida, vamos dizer se req.method é igual a GET.
Portanto, vamos atender apenas solicitações GET neste exemplo.
Caso contrário, diremos que há um “se”.
Então, se houver uma solicitação GET que vem em,
então vamos examinar,
A URL que vem em,
então vamos dizer se req.url é/,
vamos dizer fileURL igual a html.
Então, se você não obter um nome de arquivo específico, mas
você apenas enviar solicitação para o código de host local 3000.
Ele será padrão para o index.html,
caso contrário ele vai dizer fileURL é igual a req.url.
Então, desta forma, você construiu qual arquivo para servidor.
Agora, vamos dizer Vamos encontrar o caminho do arquivo,
vamos dizer caminho, Resolver,
então o módulo path suporta este método resolve, então isso irá
Traduzir isso para o arquivo de pastas caminho completo,
o arquivo que acabamos de construir,
o fileURL que acabamos de construir.
Então, isso nos dará o caminho completo para o arquivo, e
então vamos dizer FileExtension constante.
Então, se você quiser ter certeza de que
a extensão de nome de arquivo é HTML.
Então, a partir do FilePath,
vamos examinar a extensão do nome do arquivo e
, em seguida, vamos dizer se FileExt ==.
Então, se é um arquivo HTML, então sabemos como servi-lo a partir desta
relação particular do servidor HTTP nó.
Então, vamos dizer se a extensão do arquivo é HTML, então sabemos que
o arquivo é um arquivo HTML e temos os dois arquivos, index e aboutus.html.
Então vamos verificar se este arquivo existe, então
vamos dizer se o arquivo existe, FilePath.
Assim, o método existe irá verificar para ver se o arquivo existe,
então vamos dizer fs.exists (FilePath),
e este vai tomar
como um segundo parâmetro, uma função de retorno de chamada.
Portanto, observe o uso da primeira função de retorno de chamada em nosso exemplo.
Portanto, esta função de retorno de chamada será chamada com este parâmetro existe lá.
Portanto, dentro deste parâmetro de retorno de chamada, isso existe será verdadeiro ou falso.
Então este é o parâmetro de retorno para esta função de retorno de chamada.
Então aqui, vamos verificar, e
vamos dizer se (! existe), então
o que significa que o arquivo não existe,
então vamos dizer res.statusCode = 404.
Lembre-se que se o arquivo não existir, você enviará um código de status de 404 dizendo,
você não pode encontrar o arquivo.
E então vamos dizer Res.setHeader,
e vamos definir o cabeçalho para 'Content-Type',
'text/html'.
E então precisamos enviar o, arquivo HTML aqui, ou o código HTML.
Então eu vou fazer o código HTML básico, html body h1.
Erro 404,
vamos dizer, + FileURL +
'não encontrado'.
E feche, A página HTML.
Então aqui, como você percebe, você está usando a função exista
do módulo do sistema de arquivos para verificar se o arquivo existe.
Então você dá o caminho do arquivo como o primeiro parâmetro, e
o segundo é a função de retorno de chamada.
Dentro desta função de retorno de chamada, se ele diz que o existe é falso, então você vai
enviar de volta a mensagem de erro 404 padrão, dizendo que você não pode encontrar o arquivo.
E depois de fazer isso, vamos simplesmente,
retornar, caso contrário,
Vamos dizer res.statusCode
= 200, Res.setHeader,
('Content-Type', 'text/html').
Agora, precisamos ler o arquivo e enviar o arquivo para fora.
Então é aqui que, a partir do módulo do sistema de arquivos,
vamos usar o CreateReadStream,
que tomará o FilePath como um parâmetro.
Então, este método CreateReadStream irá ler no arquivo a partir deste FilePath.
E então converta isso em fluxo de bytes,
e então eles vão canalizar isso para a resposta.
Então isso será incluído na resposta, no corpo da resposta.
Assim, nós apenas pegamos o arquivo e
, em seguida, construímos na resposta aqui.
E é isso, o arquivo está pronto para ser enviado, ok?
Então, isto é, se a extensão do arquivo for html,
estamos verificando para ter certeza de que você lida com isso corretamente.
Então é aqui que você vai ler no arquivo e depois enviá-lo para fora.
Se a extensão do arquivo não for html, então, é claro, precisamos enviar uma mensagem de erro.
Então, bem ali vamos ver, vamos copiar este
particular, Código daqui.
E, em seguida, colá-lo lá dentro.
Vamos dizer, senão StatusCode = 404, Texto/html de contexto,
e a mensagem de erro diz, Erro 404, FileURL.
Não foi encontrado, mas
não é um arquivo HTML.
Então esse é o erro que vamos enviar de volta neste caso.
E, finalmente, para o último caso,
então aqui estamos dizendo o método.
Então, este mais corresponde ao método de solicitação.
Então, se o método de solicitação não é GET, mas algum outro método de solicitação,
então não vamos lidar com isso nesta versão nosso aplicativo Node.
Então, vamos enviar de volta StatusCode 404
, conteúdo html, e vamos dizer Erro 404.
E vamos dizer, método req,
Não, Suportado,
não suportado por este servidor HTML nó aqui, é isso.
Com essas mudanças, estamos prontos para reiniciar nosso navegador.
E, em seguida, deixe-o servir os arquivos HTML aqui.
Então vamos salvar as alterações, E, em seguida, ir e reiniciar o nosso servidor, e,
em seguida, examinar o que ele envia quando enviamos vários pedidos para o servidor.
Indo para o terminal, se o servidor estiver em execução,
interrompa-o digitando Ctrl+C e, em seguida, reinicie o servidor.
E quando o servidor estiver funcionando, vamos enviar algumas solicitações para ele.
Primeiro, de um navegador, e depois de Postman.
Vá para a janela do seu navegador, vamos digitar localhost:3000, e
ver que isso retorna o arquivo index.html como esperamos.
E então vamos dizer localhost: 3000/index.html,
e isso também retornará o arquivo index.html.
Agora, se enviarmos aboutus.html, ele diz Aboutus.html, e ele retorna corretamente.
Vamos agora enviar uma solicitação para aboutus.txt e ver o que ele faz.
Então ele diz que /aboutus.txt é não é um arquivo HTML.
Então vamos enviar uma solicitação para test.html.
E sabemos que test.html não existe, então diz /test.html não encontrado.
Então vemos que usando o navegador, somos capazes de buscar
os arquivos que existem, e o servidor é capaz de enviar os arquivos para o navegador.
Vamos agora para Postman e tentar gerar os mesmos pedidos,
e ver a resposta do servidor.
Em seguida, indo para Postman, vamos enviar uma solicitação GET para localhost:3000/.
E você vê que isso retorna o arquivo index.html.
Vamos enviar uma solicitação para aboutus.html.
E então você vê que ele retorna o arquivo aboutus.html.
E então vamos enviar uma solicitação para o arquivo de texto,
e então ele diz erro 404, não um arquivo HTML.
E você verá que o status aqui diz, 404 não encontrado.
E então vamos, em vez de enviar um pedido GET,
ver que esta é a vantagem de usar o Postman, eu vou enviar um pedido PUT.
E você notará que isso diz, Erro: PUT não suportado, e
assim com o Status 404 aqui, e assim por diante.
Então é assim que você pode configurar um servidor HTTP nó
para ser capaz de servir arquivos, arquivos HTTP neste caso particular.
Agora você pode facilmente imaginar estendendo
este servidor HTTP para lidar com muitos tipos diferentes de arquivos e assim por diante.
Mas é claro, correspondentemente,
o código também ficará mais complicado do que o que temos neste momento.
Com isso, completamos este exercício.
Neste exercício, vimos como podemos configurar um
servidor HTTP baseado em nós simples que serve arquivos do nosso site de servidor.
[ MUSIC]