Um tutorial introdutório para desenvolvedores Java combinado com programação Node.js.

Em primeiro lugar, devo admitir que, como desenvolvedor Java com mais de dez anos de experiência em desenvolvimento, formei rotinas inerentes para resolver a maioria dos problemas, embora muitas vezes pareçam complicados e complicados. Por exemplo, se você quiser ler um arquivo, você deve inicializar uma instância do BufferedReader e passar um FileReader. Isso é quase lógico. Escrevi esse código em muitos projetos que considero de "nível empresarial" e gosto muito dele. Muito. Processo, pode-se dizer que sou apenas um fanático por Java que despreza outras linguagens.

Se você está lendo esta postagem do blog, pode ter caído no mal-entendido que eu tive há muitos anos. Como desenvolvedor qualificado, você deve aprender constantemente novas tecnologias e escolher tecnologias apropriadas com base nas necessidades reais de trabalho. Embora eu esteja envelhecendo e um dia possa me cansar de java. Mas eu realmente descobri uma coisa nova e interessante agora, node.js é como uma criança ganhando um brinquedo novo para mim. Nesta postagem do blog, vou primeiro mostrar como criar um Rest simples usando o serviço Java EE para ler o banco de dados MongoDB. Então usarei node.js para obter a mesma funcionalidade e você entenderá mais facilmente o entusiasmo dessa nova linguagem de desenvolvimento.

Comece com o básico – o que é Node.js?

Primeiramente quero deixar claro que o Node.js não é uma linguagem “da moda” que só as “pessoas da moda” usam. Embora tenha começado com esse entendimento, tenho o prazer de informar que o Node.js é uma linguagem madura - e na era atual da Internet, ele encontrou seu caminho em grandes empresas, alimentando alguns dos sites de maior tráfego. Node.js é uma ferramenta muito útil em seu conjunto de habilidades e irá surpreendê-lo com a facilidade de construir código estável, seguro e de alto desempenho.

Resumindo, Node é uma linguagem para atividades do lado do servidor. Ele usa linguagem Javascript e existem muitas bibliotecas disponíveis, como modelos npm. Você pode comparar esses modelos npm com pacotes .jar em Java. Quando você precisa de uma funcionalidade e não tem vontade de escrever todo o código sozinho, é provável que o recurso que você procura já esteja fornecido no modelo npm.

Os aplicativos de nó normalmente são executados para maximizar a eficiência, aproveitando E/S sem bloqueio e eventos assíncronos. Uma coisa que os desenvolvedores Java precisam saber é que os aplicativos Node são executados em um único thread. No entanto, o código do nó backend usa vários threads para operações como acesso à rede e a arquivos. Por esse motivo, o Node é perfeito para aplicações que exigem experiência em tempo real.

Continuar - suporte IDE

Você pode ser como eu e "viver" e "respirar" no IDE. Isso pode ser devido ao fato de Java ser muito prolixo e exigir que escrevamos código constante para completar funções durante o processo de desenvolvimento de software. Depois que descobrimos os benefícios da conclusão de código, aprendemos lentamente a usar o IDE para gerenciamento de arquivos, depuração e outros recursos muito úteis. Basta dizer que adoro usar um IDE e continuo a usá-lo quando trabalho com Nodeb. A seguir estão o primeiro lote de IDEs que atualmente suportam Node:

1. Eclipse - Deve ser fácil começar se você já estiver usando em Java. Basta instalar o plugin Node.js.
2.JetBrains IntelliJ IDEA - um IDE comercial muito popular. Este é meu IDE favorito até agora.
3.Microsoft Visual Studio – Sim, você leu certo. O Node cresceu a tal ponto que a Microsoft adicionou suporte nativo para ele no Visual Studio. Esta implementação é muito estável e VS é meu segundo IDE favorito. Curiosamente, eu só uso VS para alguns projetos básicos do Node.
4.CodeEnvy - um IDE baseado na web
5.Cloud9 – um IDE baseado na web
6.SublimeText 2 - Um editor de texto simples que está se tornando cada vez mais popular entre os desenvolvedores devido à sua natureza leve.

Estes são alguns dos meus IDEs favoritos para trabalhar em projetos baseados em Node. Apenas um exemplo.

Comece com um exemplo

No restante desta postagem do blog, criaremos um serviço REST simples usando Java EE e Node.js. Este serviço REST simplesmente lerá as informações do banco de dados MongoDB e retornará os resultados ao solicitante. A instalação e configuração do servidor de aplicativos Java e do banco de dados MongoDB estão além do escopo deste artigo.

Crie nosso aplicativo Java

Etapa 1: configurar o arquivo pom.xml

Vamos chamar este exemplo de restexample e usarei o servidor de aplicativos JBoss EAP. A primeira coisa que precisamos fazer é configurar nosso arquivo pom.xml para gerenciamento de dependências usando o sistema de compilação Maven. A seguir está o arquivo pom.xml que contém as dependências necessárias em nosso aplicativo restexample:

 <projeto xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http:/ /maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>restexample</groupId> <artifactId>restexample</artifactId> <packaging>war</packaging> <version>1.0</version> <name>restexample</name> <repositórios> <repositório> <id>eap</id> <url>http://maven.repository.redhat.com/techpreview/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>eap</ id> <url>http://maven.repository.redhat.com/techpreview/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </pluginRepository> </pluginRepositories> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven .compiler.source>1.6</maven.compiler.source> <maven.compiler.target>1.6</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.jboss.spec</groupId> <artifactId>jboss-javaee-6.0</artifactId> <version>3.0.2.Final-redhat-4</version> <type>pom</type> <scope>fornecido</scope> </dependency> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>2.9.1</version> </dependency> </dependencies> </project>

Legal, bastante detalhado, mas espero que você consiga entender o código. Nesta postagem do blog presumo que os leitores já conheçam Java, então não vou explicar os detalhes.

Etapa 2: Crie o arquivo beans.xml e configure nosso mapeamento de servlet

Como parte do exemplo, usaremos CDI (Context Dependency Injection) em nossa classe de acesso ao banco de dados. De acordo com as instruções oficiais de configuração do CDI, se uma aplicação quiser utilizar CDI, ela deverá incluir um arquivo beans.xml no diretório WEB-INF da aplicação. Então vamos criar esse arquivo e configurá-lo com as informações que precisamos. Vá para o diretório /src/main/webapp/WEB-INF e crie um arquivo beans.xml e adicione o seguinte código:

 <?xml version="1.0"?><beans xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema- instância" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://jboss.org/schema/cdi/beans_1_0.xsd"/>

Também precisamos configurar o mapeamento de servlet para nossa API RESI no arquivo web.xml. Adicione o seguinte elemento de mapeamento de servlet ao arquivo no diretório /src/main/webapp/WEB-INF:

 <servlet-mapping> <servlet-name>javax.ws.rs.core.Application</servlet-name> <url-pattern>/ws/*</url-pattern></servlet-mapping>

Etapa 3: Crie a classe DBConnection

Neste ponto, configuramos o projeto e nosso arquivo pom.xml já contém as dependências do driver do banco de dados MongoDB. Lembre-se de certificar-se de que os drivers necessários foram empacotados em nosso aplicativo. A próxima coisa que precisamos fazer é criar uma classe para gerenciar a conexão com o banco de dados. Crie um novo arquivo chamado DBConnection.java, coloque-o no diretório /src/main/java/com/strongloop/data e adicione o seguinte código a este arquivo:

NOTA: Certifique-se de que a instalação do seu banco de dados MongoDB esteja configurada com os detalhes de autorização de conexão apropriados!

 pacote com.strongloop.data; importar java.net.UnknownHostException; importar javax.annotation.PostConstruct; importar javax.enterprise.context.ApplicationScoped; ; @Named@ApplicationScopedpublic class DBConnection { banco de dados privado mongoDB público; DBConnection() { super(); } @PostConstruct public void afterCreate() { String mongoHost = "127.0.0.1" String mongoPort = "27001" String mongoUser = "strongloop; String mongoPassword = "rocks"; String mongoDBName = "restexample" ;int porta = Integer.decode(mongoPort); null; try { mongo = new Mongo(mongoHost, port } catch (UnknownHostException e) { System.out.println("Não foi possível conectar ao MongoDB: " + e.getMessage() + " :: " + e. getClass()); } mongoDB = mongo.getDB(mongoDBName); mongoPassword.toCharArray()) == false) { System.out.println("Falha ao autenticar o banco de dados ");

Etapa 4: importar dados para o MongoDB (mmmm beer)

Em nosso projeto queremos carregar uma lista de todas as cervejas com o nome Pabst. Se você é novo na indústria cervejeira, experimente a American Light Ale da Pabst Brewing. Essas cervejas apresentam fitas azuis e designs Colt e incluem todos os tipos de bebidas de malte.

Primeiro você precisa baixar um arquivo json que contém todos os dados que precisam ser retornados. Você pode usar o seguinte URL para fazer isso:
https://dl.dropboxusercontent.com/u/72466829/beers.json

Após o download, use o comando mongoimport para importá-lo para o banco de dados. O comando é o seguinte:

 $ mongoimport --jsonArray -d seuNomeDB -c cervejas --type json --file /tmp/beers.json -h seuMongoHost --port seuMongoPort -u seuMongoUsername -p suaMongoSenha

Você pode ver os seguintes resultados:

 conectado a: 127.0.0.1:27017Terça, 10 de junho 20:09:55.436 verificar 9 24Terça, 10 de junho 20:09:55.437 importou 24 objetos

Etapa 5: Criar objeto modelo Beer

Criamos uma classe de conexão de banco de dados e carregamos as informações da cerveja no banco de dados MongoDB. É hora de criar um objeto modelo para controlar nossas informações de cerveja. Crie um novo arquivo chamado Beer.java e coloque-o no diretório /src/main/java/com/strongloop/data. Após criar o arquivo, adicione o seguinte código a ele:

 pacote com.strongloop.data; public class Beer { private String id; private String descrição; public String getId () public void setId (String id) { this.id = id } public String; getName() { return name; } public void setName(String nome) { this.name = name; } public String getDescription() { return description; esta.descrição = descrição }}

Observação: o arquivo JSON fornecido contém mais informações que usaremos, então confira e adicione algumas funcionalidades extras para ampliar sua experiência de aprendizado.

Etapa 6: Criar serviço REST

Adivinha o que fazer? Ok, finalmente estamos prontos para criar um serviço web baseado em REST que nos permitirá carregar as informações da cerveja na etapa anterior. Para fazer isso, precisamos criar um novo arquivo chamado BeerWS.java e colocá-lo no diretório /src/main/java/com/strongloop/webservice. Após criá-lo, adicione o seguinte código:

 pacote com.strongloop.webservice; importar java.util.ArrayList;importar java.util.List;importar javax.enterprise.context.RequestScoped;importar javax.inject.Inject;importar javax.ws.rs.GET;importar javax.ws .rs.Path;importar javax.ws.rs.Produces;importar javax.ws.rs.QueryParam;importar com.strongloop.data.DBConnection;importar com.strongloop.data.Beer;importar com.mongodb.BasicDBObject;importar com.mongodb.DB;importar com.mongodb.DBCollection;importar com.mongodb.DBCursor;importar com.mongodb. DBObject; @RequestScoped@Path("/cervejas")public class BeerWS { @Inject private DBConnection dbConnection; private DBCollection getBeerCollection() { DB db = dbConnection.getDB(); (); theBeer.setName(dataValue.get("nome")); theBeer.setDescription(dataValue.get("nome")); theBeer.setId(dataValue.get("_id").toString() }); // Obtém todas as cervejas @GET() @Produces("application/json") public List<Beer> getAllBeers() { ArrayList<Beer> allBeersList = new ArrayList<Beer>(); DBCollection cervejas = this.getBeerCollection(); ())); } } finalmente { cursor.close();

Etapa 7: procure informações sobre cerveja bobas

Ah, pronto. Escrevemos um serviço REST que pode recuperar todas as informações sobre cerveja do banco de dados. Agora, para implantar seu código em seu servidor de aplicativos, abra o seguinte endereço em seu navegador para ver se funciona bem:
http://local do seu servidor/ws/cervejas

Se estiver tudo bem, você verá uma lista com todas as informações da cerveja, conforme mostrado abaixo:

Criar aplicativo Node

Se você seguir as etapas acima para programar em java, perceberá que, embora a criação de aplicativos usando javaEE esteja progredindo muito rapidamente, ainda é muito problemático criar um aplicativo simples como um serviço REST. Não me interpretem mal, ainda gosto de usar javaEE, mas acho que para muitos cenários, como a criação de serviços REST que retornam dados json, o Node é mais adequado. A seguir, criaremos um serviço web simples usando a API LoopBack do StrongLoop. Além disso, mostrarei como instalar o Node no Apple OSX.

Etapa 1: instalar o nó

A maneira mais fácil de instalar o Node é por meio de um pacote binário compatível com a maioria dos sistemas operacionais. Abra seu navegador e visite a página abaixo para baixar a versão aplicável de acordo com seu sistema operacional:
http://nodejs.org/download/

Após a conclusão do download, você verá o seguinte:

Se você estiver usando Mac OSX, clique no arquivo .pkg genérico. Isso salvará o instalador em seu computador. Após baixar o arquivo, clique duas vezes nele para iniciar o programa de instalação. Você verá a seguinte caixa de diálogo de instalação:

Continue a instalação por padrão. Após a instalação bem-sucedida, clique no botão Fechar para sair do programa de instalação.

Muito simples, certo?

Etapa 2: Instale o LoopBack usando NPM

Agora que o Node foi instalado no sistema local, o próximo passo é instalar o pacote LoopBack fornecido pelo StroopLoop. LoopBack é um pacote de código-fonte de API aberto. Quando você aprende a usar o Node para desenvolver e implantar software, o LoopBack pode tornar a programação mais fácil.

Para instalar o LoopBack, usaremos a linha de comando npm, que faz parte da linguagem principal do Node. NPM é uma ferramenta oficial de gerenciamento de pacotes usada para instalar bibliotecas de classes ou modelos dos quais os aplicativos dependem. Se você é um programador Java, pode comparar o NPM ao Maven. Usando o Maven para construir um projeto, os desenvolvedores podem configurar os pacotes jar ou modelos dos quais o projeto depende em pom.xml. Quando o projeto começar a ser compilado, o Maven baixará todos os arquivos dependentes e introduzirá o pacote jar no projeto. O NPM funciona da mesma forma que o Maven. Para alguns projetos especiais, ele usa o arquivo package.json para configurar os arquivos dos quais o projeto depende. Você também pode usar a linha de comando para baixar arquivos dependentes para o sistema local. Se você não entende isso, não se preocupe, descreveremos o arquivo package.json em detalhes nas próximas etapas.

Para instalar o LoopBack, usamos uma linha de comando simples para baixar e instalar todos os arquivos dependentes. Abra a janela de linha de comando da janela e digite o seguinte comando:

 $ npm instalar -g loop forte

Dica: Durante a instalação, pode ser necessário usar outra conta de usuário para executar este comando.

O que esta linha de comando significa? O parâmetro -g informa ao npm que queremos instalar o pacote strong-cli. O parâmetro -g torna este pacote compatível com qualquer sistema e aplicativo. Depois de executar o comando acima, o NPM baixará todos os arquivos dependentes. O tempo de download depende da velocidade da sua internet e pode levar vários minutos.

Etapa 3: crie o aplicativo

Criar um aplicativo usando a API LoopBack é simples. Abra a janela de linha de comando da janela e use o seguinte comando para criar um novo exemplo de reste do aplicativo.

 $ loopback slc

Em seguida, ele solicitará o nome do caminho raiz do projeto. Neste exemplo, restexample é usado. Em seguida, ele solicitará um nome de aplicativo. Use o reexemplo padrão.

O comando slc agora criou um aplicativo LoopBack chamado restexample e configurou o aplicativo. Se você executar o comando acima novamente e ainda usar restexample para nomeá-lo, o LoopBack criará um novo diretório. Você pode usar o comando cd para modificar o caminho raiz do aplicativo.

 $ cd reexemplo

Agora que criamos um aplicativo, configuramos o MongoDB como a fonte de dados do aplicativo.

Etapa 4: definir a fonte de dados

Para nos conectarmos ao MongoDB, precisamos adicionar uma fonte de dados ao aplicativo e executar o seguinte comando:

 $ loopback slc: fonte de dados

No prompt pop-up, você pode inserir qualquer nome de fonte de dados personalizado. Aqui, escolha myMongo.

 [?] Insira o nome da fonte de dados: myMongo

Dessa forma, anexamos a definição da fonte de dados do backend a um conector real desenvolvido com StrongLoop. Aqui selecionamos o conector MongoDB da lista.

 [?] Selecione o conector para myMongo:PostgreSQL (suportado pelo StrongLoop)Oracle (suportado pelo StrongLoop)Microsoft SQL (suportado pelo StrongLoop)MongoDB (suportado pelo StrongLoop)Serviços web SOAP (suportados pelo StrongLoop)Serviços REST (suportados pelo StrongLoop)Neo4j ( fornecido pela comunidade)(Mova para cima e para baixo para revelar mais opções)

Etapa 5: Aponte para a fonte de dados real

Para conectar-se ao MongoDB, precisamos apontar para a instância real do MongoDB que define todas as informações de configuração da fonte de dados no arquivo datasource.json. Este arquivo está localizado no diretório raiz/servidor do aplicativo. da seguinte maneira. O MongoDB adiciona uma fonte de dados:

 { "db": { "name": "db", "connector": "memory" }, "myMongo": { "name": "myMongo", "connector": "mongodb" "url": "mongodb: //localhost:27017/restexample" }}

Observação: certifique-se de fornecer o URL de conexão correto ao banco de dados MongoDB. Para este exemplo, criei um banco de dados chamado restexample, que é usado como fonte de dados.

Etapa 6: importar dados para o MongoDB (cerveja mmmmm)

Conforme mencionado na parte Java deste artigo, precisamos carregar o conjunto de dados no banco de dados MongoDB. Se você concluiu esta etapa de acordo com o método mencionado neste artigo e planeja usar o mesmo banco de dados, pode ignorar a etapa. 6 e vá diretamente para a Etapa 7.

Primeiramente, é necessário baixar um arquivo JSON contendo todas as informações a serem retornadas, que pode ser obtido na seguinte URL:
https://dl.dropboxusercontent.com/u/72466829/beers.json

Após o download do arquivo do conjunto de dados, use diretamente o seguinte comando mongoimport para carregá-lo no banco de dados:

 $ mongoimport --jsonArray -d seuNomeDB -c cervejas --type json --file /tmp/beers.json -h seuMongoHost --port

Você deverá ver os seguintes resultados:

 conectado a: 127.6.189.2:27017Terça, 10 de junho 20:09:55.436 verificar 9 24Terça, 10 de junho 20:09:55.437 importou 24 objetos

Passo 7: Crie nosso próprio modelo de cerveja

No mundo Java, podemos pensar no modelo de objeto. Ele representa esse objeto, mas aqui, esse objeto é Beer, que fornece uma maneira simples de criar objetos de modelo por meio da linha de comando. digite o seguinte comando:

 $ loopback slc:modelo

Isso abrirá uma sessão interativa para definir o modelo. A primeira coisa que você precisa inserir é o nome do modelo, digite "cerveja" aqui. Em seguida, será solicitada a fonte de dados à qual este modelo deve ser anexado. a fonte de dados myMongo criada anteriormente.

 [?] Insira o nome do modelo: beer[?] Selecione a fonte de dados para anexar beer:db (memory)myMongo (mongodb)

Em seguida, ele pergunta se esta API deve ser exposta por meio de REST. Claro, esperamos que sim.

 [?] Expor cerveja por meio da API REST?

Finalmente, selecione o nome plural da rede para o modelo. Aqui o modelo é denominado cerveja, então o plural é feijão (padrão). Pressione Enter para aceitar o padrão.

 [?] Forma plural personalizada (usada para construir URL REST):

Em seguida, você será solicitado a definir as propriedades do modelo. Para este programa de exemplo, nos concentramos no nome e na descrição da cerveja.

 Insira um nome de propriedade vazio quando terminar.[?] Nome da propriedade: nome

Contanto que você pressione Enter, você será solicitado a inserir o tipo de dados de cada atributo especificado. O primeiro item é o nome, selecione aqui o tipo de string e pressione.

 Enter.[?] Tipo de propriedade: (Use as teclas de seta)stringnumberbooleanobjectarraydatebuffergeopoint(other)

Em seguida, crie o atributo de descrição da mesma forma e, em seguida, será solicitado que você insira o tipo de dados. Também é um tipo de string, selecione a opção de string e clique.

 Enter.Vamos adicionar outra propriedade de cerveja.Insira um nome de propriedade vazio quando terminar.[?] Nome da propriedade: descriptioninvoke loopback:property[?] Tipo de propriedade: string[?] Obrigatório?

Parabéns! Você concluiu a criação de objetos de modelo usando LoopBack combinado com Node. Se quiser ver o que realmente foi criado durante esse processo, você pode abrir o arquivo beer.json localizado no diretório root/common/models do aplicativo e rolar para cima. no final do arquivo, você verá o seguinte modelo:

 { "nome": "cerveja", "base": "PersistedModel", "propriedades": { "nome": { "tipo": "string", "required": verdadeiro }, "descrição": { "tipo" : "string", "required": true } }, "validações": [], "relações": {}, "acls": [], "métodos": []}

Como você pode ver aqui, criamos um modelo e, ao mesmo tempo, os atributos de nome e descrição foram atribuídos a este modelo.

No arquivo /server/model-config.js, você pode notar que o arquivo contém alguns campos adicionais, incluindo público e fonte de dados. O campo público especifica que queremos expor este modelo para o exterior por meio de um serviço de rede REST. O campo é Especifique a fonte de dados que será usada para operações CRUD neste modelo.

 "cerveja": { "dataSource": "myMongo", "public": true }

Passo 8: Aproveite a alegria de ver cervejas

Parabéns! Você criou seu primeiro aplicativo Node.js que contém um serviço da web REST que pode obter informações sobre cerveja. Finalmente, tudo o que precisamos fazer é implantar o aplicativo.

Felizmente, a implantação já é fácil. Isso pode ser feito executando o seguinte comando no diretório raiz do aplicativo:

 $ slc executado

Assim que o aplicativo estiver em execução, você poderá confirmar se a implantação foi bem-sucedida acessando a seguinte URL em seu navegador:

http://0.0.0.0:3000/api/cervejas

Muito legal, não é?

LoopBack também contém uma página que permite visualizar todos os serviços disponíveis do aplicativo, incluindo o modelo Beer e o serviço REST que criamos.

http://0.0.0.0:3000/explorador

Depois que a página for carregada com sucesso, você verá a seguinte interface. Criamos o nó beans como parte do blog e destaquei o endpoint /beers:

Você pode clicar em /beers para expandir as APIs disponíveis. Você pode operá-las e testá-las, conforme mostrado na figura abaixo:

para concluir

Nesta postagem do blog, mostro como usar Java EE para criar um serviço REST que retorna dados de listagem de produtos de cerveja da Pabst Beer Company. Posteriormente, usei node.js e a estrutura de loopback baseada em node.js para implementar o serviço rest com a mesma função usando muito pouco código. O mais importante é que a API LoopBack também fornece uma implementação padrão para adição, exclusão, verificação e modificação de entidades de cerveja, para que possamos obter um serviço de descanso com funções completas de adição, exclusão, verificação e modificação sem escrever uma única linha de código.

A lista a seguir compara os respectivos recursos de javaEE e node.js mencionados na postagem do blog:

O que vem a seguir?

O próximo Node v0.12 trará pelo menos 8 novos recursos interessantes, quais serão eles? Visite a página "Novidades no Node.js v0.12" para saber mais.
Interessado em treinamento e certificação relacionados ao Node? O StrongLoop oferece uma variedade de serviços para atender às suas necessidades.