Primeiros passos com Node.JS

Introdução

Node.JS é um interpretador de javascript que roda do lado do servidor. Pensado para trabalhar como um servidor web, ele foi criado como uma plataforma sobre o runtime do interpretador V8 do Google Chrome.

Isso é bom porque o V8 transforma o javascript em código nativo de maquina, o que poderia ser traduzido como performance. A idéia central é escrever aplicações em rede rápidas e escaláveis através de chamadas assíncronas.

Muito interessante, não? Mas por que escrever um monte de código para disponibilizar um servidor web, se já podemos fazer isso com um Apache Tomcat ou qualquer outro servidor? Bem, esta pergunta nos traz ao presente texto.

(Para concluir este artigo com sucesso é necessário ter o node instalado e configurado na máquina. Maiores informações aqui.)

Criando um servidor Node simples:

var http = require('http');

http.createServer(function(req, res) {
    res.writeHead(200, {
        'Content-Type': 'text/plain'
    });
    res.end('Hello World\n');
}).listen(1337, '127.0.0.1');

console.log('Server running at http://127.0.0.1:1337/');
Listagem 1 -Criar o arquivo server.js

Executar:

> node server.js

Pronto! Agora temos o servidor rodando localmente. Basta acessar a URL informada para ver a aplicação respondendo a sua primeira requisição ao servidor node.

Dependências. Dependências em toda parte.

Enquanto desenvolvedores Java temos por verdade que “nada se escreve, tudo se copia”. Por acreditar nisso utilizamos o nosso querido Maven para organizar nossa bagunça e deixar nossas dependências registradas de forma fácil e organizada.

Por que abriríamos mão de uma solução interessante como o arquivo pom.xml para entrar na bagunça dos arquivos JS? Bem, esta pergunta nos leva ao próximo assunto:

NPM

O npm pode ser visto como uma ferramenta disponibilizada com o node para facilitar a vida dos desenvolvedores javascript.

Com esta ferramenta se torna fácil compartilhar e reusar aquele teu código maravilhoso em todo projeto que você desejar. Mesmo!

A sintaxe do arquivo é o já conhecido formato JSON. Dentro deste arquivo você irá declarar todas as bibliotecas que você irá disponibilizar para o server-side da tua aplicação em node.

Mais informações, aqui.

Criando um arquivo de configuração NPM simples:

{
    "name": "hello-node-world",
    "version": "0.0.1",
    "description": "A very simple node project.",
    "main": "server.js",
    "scripts": {
        "start": "node server.js"
    },
    "dependencies": {
        "express": "^4.11.2",
        "body-parser": "^1.11.0",
        "errorhandler": "^1.3.3",
        "method-override": "^2.3.1"
    }
}
Listagem 2 – Criar o arquivo package.json

Alguns campos são auto-explicativos, outros nem tanto:

scripts: define scripts que o node poderá executar em um terminal, no nosso caso foi definido um script chamado ‘start’ que inicializará o servidor chamando o node e passando o arquivo de configuração ‘server.js’.

dependencies: objeto onde declaramos as dependências que serão disponibilizadas ao servidor e a respectiva versão. Definimos aqui algumas dependências que serão úteis até o final deste artigo.

Executando

> npm install

Executando os módulos

Nesse momento temos nosso servidor configurado e pronto para rodar e temos também nosso arquivo package.json com todas as dependencias e scripts declarados.

Para executar tudo:

> npm start

O NPM irá procurar pelo arquivo package.json e em seguida o script chamado ‘start’.

Nesse ponto você deve ter percebido que é simples criar configurações complexas para startup de aplicações e declarar dependências de uma forma simples. Aposto que se você fez tudo até aqui deve estar achando que não houve grandes complicações.
Essa é a idéia, usar ferramentas já conhecidas como javascript e arquivos json para manter um ambiente de desenvolvimento simples e controlado.

Um exemplo mais útil

Que tal se alterássemos nossos arquivos de configuração para subir uma aplicação web com recursos estáticos e dinâmicos?

A idéia é utilizar o node como backend e reunir alguns recursos e criar um frontend estático disponibilizado através do node.
Para isso será necessário informar ao node onde encontrar nosso arquivo index para que o mesmo seja disponibilizado.

var express = require("express"),
    app = express(),

    bodyParser = require('body-parser'),
    errorHandler = require('errorhandler'),
    methodOverride = require('method-override'),
    hostname = process.env.HOSTNAME || 'localhost',
    port = parseInt(process.env.PORT, 10) || 4567;

app.use(methodOverride());

app.use(bodyParser.json());

app.use(bodyParser.urlencoded({
    extended: true
}));

app.use(express.static(__dirname + '/public'));

app.use(errorHandler({
    dumpExceptions: true,
    showStack: trueo compressor.io
}));

app.get("/", function(req, res) {
    res.redirect("/index.html");
});

console.log("Simple server listening at http://" + hostname + ":" + port);

app.listen(port, hostname);
Listagem 3 – Alterar o arquivo server.js

Criar a pasta ‘public’ e o arquivo index.html dentro da mesma.

<!doctype html>
<html lang="pt-br">
    <head>
        <meta charset="UTF-8">
        <title>Hello</title>
    </head>

    <body>
        <p>Hello world!</p>
    </body>
</html>
Listagem 4 – Escrever o index.html

Executando:

> npm start

Após isto, será exibida a URL para acessar a aplicação recém criada. Esta URL é parecida com o exemplo:

> Simple server listening at http://localhost:4567

Será necessário apenas acessar a URL informada para ver a aplicação rodando.

Overview sobre as dependências utilizadas:

Express.js – https://github.com/strongloop/express
O express é um framework minimalista para desenvolvimento de aplicações web com um sistema de roteamento incluso e um conjunto de views.

Method-Override.js: https://github.com/expressjs/method-override
A API http nativa do node não é apropriada para a criação de aplicações complexas. Seu gerenciamento de rotas e alguns outros recursos são pobres. O express melhoras estes requisitos entre outros além de suportar RESTFul

Body-Parser.js: https://github.com/expressjs/body-parser
O express body parser permite a construção de objetos JSON a partir da submissão de dados de um formulário HTML.

ErrorHandler.js: https://github.com/expressjs/errorhandler
Esta função permite a manipulação correta de erros. Ao invés de colocar a aplicação em um estado de exceção, será possível manipular o erro escrevendo o teu próprio tratamento, logando e devolvendo uma resposta apropriada para o frontend.

Method-Override.js: https://github.com/expressjs/method-override
Esta função permite ao desenvolvedor fazer a sobrescrita de rotas utilizando métodos HTTP diferentes.

Código fonte

Todo o código fonte aqui criado está disponível no github da MATERA em: https://github.com/materasystems/hello.node

Por ALEXIS BARBIERI SAAVEDRA

Postado em: 26 de maio de 2015

Confira outros artigos do nosso blog

REST não é JSON

21 de agosto de 2017

Bruno Sofiato

[Webinar] Profile de aplicações Java com Oracle Mission Control e Flight Recorder

24 de julho de 2017

Danival Calegari

Criando Mocks de serviços REST com SoapUI

27 de junho de 2017

Monise Costa

JavaScript 6: diferença entre var, let e const

09 de maio de 2017

Otávio Felipe do Prado

Deixe seu comentário