Agora que aprendemos sobre o driver MongoDB nó, o módulo nó,
que permite que nosso aplicativo nó seja capaz de interagir
com um servidor MongoDB, neste exercício,
vamos usar o módulo nó e usar os vários métodos que são
suportados pelo módulo nó para fornecer introdução com nosso servidor MongoDB.
Para começar, vá para
a pasta NodeJS que você tem usado para armazenar todos os seus exemplos
e, em seguida, crie uma nova pasta chamada node-mongo.
Nesta pasta, vamos desenvolver
o aplicativo NodeJS que interage com o nosso servidor MongoDB.
Agora, certifique-se de que o seu servidor MongoDB está funcionando,
então, no exercício anterior, já vimos como o nosso servidor MongoDB pode ser iniciado.
Então, mantenha o servidor MongoDB funcionando e em
outra janela de terminal ou guia terminal ou janela de comando,
vá para a pasta node-mongo que você acabou de
criar e inicialize um aplicativo de nó aqui.
Então, deixe-me digitar npm init e
vamos nomear o aplicativo como Node-Mongo e versão,
descrição Node MongoDB Exemplo,
eo ponto de entrada,
eo autor, assim como temos sido preenchendo os exercícios anteriores.
Então, uma vez que o arquivo package.json é inicializado,
abra isso no editor de sua escolha.
Agora indo para o arquivo package.json,
deixe-me introduzir outro script aqui exatamente como fizemos anteriormente, então,
vamos dizer “start”: “node index” e salvar as alterações.
Voltando ao terminal,
vamos instalar o módulo do nó MongoDB.
Então, digite npm install mongodb @3 .0.10 —save.
Nós também instalaremos o módulo do nó assert, então,
vamos dizer npm install assert @1 .4.1 —save.
O módulo assert nos permite usar o assert
para verificar se há valores de verdade ou falsos dentro de nossa aplicação,
e você vai me ver usando-o mais tarde.
Agora que temos instalado esses módulos de nó,
vamos criar nosso aplicativo nó que interage com o servidor MongoDB.
Voltando para o editor,
na pasta do projeto,
criar um arquivo chamado index.js,
e é aqui que vamos criar
o aplicativo nó que interage com o nosso servidor MongoDB.
Então, nesta aplicação,
vamos digitar const Mongoclient,
e então eles vão dizer,
require (`mongodb`), o módulo de nó MongoDB que já instalamos,
e então isso nos forneceria com
o MongoClient que nos permite conectar ao servidor MongoDB.
Além disso, exija o módulo assert.
Agora, para iniciar uma conexão com o servidor MongoDB,
vamos criar uma URL de nome constante que será a URL onde o servidor MongoDB pode ser
acessado e o bebê acessar isso é
dizendo mongodb: //localhost: 27017/.
Lembre-se que este é o número da porta em que seu servidor MongoDB está
executando 27017 const dbname=,
e então eles vamos dizer Confusion.
Lembre-se de que criamos
o banco de dados Confusion em nosso servidor MongoDB no exercício anterior
, então, vamos acessar que o banco de dados Confusion que criamos anteriormente.
Agora, para acessar o servidor, vamos dizer mongoClient.connect.
Então, o método connect nos permite conectar ao MongoClient do nosso servidor MongoDB,
e então vamos dizer que isso leva a URL como o primeiro parâmetro,
a URL do servidor MongoDB como o primeiro parâmetro.
O segundo parâmetro é uma função de retorno de chamada.
Então, a função de retorno de chamada tem dois parâmetros, o valor de erro
e cliente, que podemos então usar
para se conectar ao nosso banco de dados e, em seguida, executar várias operações.
Então, dentro desta função callback, a
primeira coisa que vamos fazer é verificar para se certificar de que o erro não é nulo.
Então, o assert irá verificar para ver se o erro é igual a null,
então a função assert nos permite executar várias verificações em valores.
Então, verificamos para ter certeza de que o erro não
é, se não for nulo,
então isso significa que há um erro e então vamos mostrar o erro na tela.
Então, esse é o uso da função de afirmação aqui.
Agora, se isso não acontecer,
então isso significa que temos conectado corretamente ao servidor,
então vamos dizer `conectado corretamente ao server`
const db= client.db (dbname) para se conectar ao banco de dados,
então podemos dizer const collection db. ,
então o db nos fornecerá vários métodos que nos permitem
interagir com o servidor, então vamos dizer db.collection (`dishes`) Então,
vamos tentar acessar a coleção de pratos dentro deste banco de dados.
Agora, a próxima coisa que vamos tentar fazer é
collection.insertone então vamos tentar inserir um objeto na coleção,
e este objeto seria com
o nome e a descrição, “test”.
Então, esta coleção fornece este método chamado
InsertOne, que nos permite inserir um documento nesta coleção,
eo documento é o primeiro argumento para este método aqui.
O segundo argumento para o método é uma função de retorno de chamada,
e a função de retorno de chamada leva dois parâmetros, erro e resultado.
Então, dentro desta função de retorno de chamada,
se o resultado for obtido,
então somos capazes de acessar a coleção e, em seguida, executar outras operações.
Então, aqui, a primeira coisa que vamos fazer é verificar se o erro não é nulo.
Então, vamos fazer uma afirmação lá,
e então aqui podemos dizer, “Após Inserir”.
Então, depois de inserir, então vemos que
obtemos o valor do resultado que é retornado lá, então este resultado.
Este resultado também irá fornecer
esta propriedade OPS que diz quantas operações acabaram de ser realizadas com sucesso.
Então, é isso que vou imprimir.
Então, ele vai dizer número inserido é um.
Então, o que significa que este documento em particular foi inserido no banco de dados.
Então, isso é o que vamos confirmar aqui.
Então, depois disso, vamos executar outra opção,
uma operação na coleção, e dizer,
coleção encontrar, e vamos tentar procurar por todos os registros na coleção.
Então, aqui, vamos fornecer uma string JSON vazia ou objeto JavaScript nível correspondente.
Então, ele vai procurar por tudo o que está lá na coleção,
e então, fornecer isso para nós.
Em seguida, isso pode ser convertido em uma matriz de objetos JSON.
Então, é por isso que chamamos o ToArray,
e isso leva uma função de retorno de chamada como parâmetro.
O primeiro parâmetro, é claro, é o valor do erro, então, novamente,
verificamos se o erro não é nulo.
Então vamos dizer, console.log encontrado
e, em seguida, imprimir o que quer que tenha sido encontrado,
e diremos console.log.
Então, o segundo parâmetro aqui, docs,
retornará todos os documentos desta coleção
que correspondam a qualquer critério que você especificar aqui.
Como isso está vazio,
então isso significa que todos os documentos da coleção serão devolvidos para nós.
Você pode especificar um filtro aqui,
dizendo que o nome é igual a um valor
e, em seguida, somente os documentos que correspondem a esse valor serão recuperados.
Então aqui, deixe-me apenas imprimir os documentos aqui,
para indicar que este item
foi inserido na coleção e, em seguida, será recuperado,
e então vamos apenas imprimi-lo apenas para ter certeza de que o documento que acabamos de
inserir na operação anterior está de fato na coleção,
e então vamos imprimir isso aqui.
Agora depois disso, então vamos usar
o método DropCollection aqui.
Então, o DropCollection irá soltar a coleção especificada aqui.
Então, vamos dizer pratos DropCollection,
então eu vou apenas remover a coleção de pratos do meu banco de dados.
Então, eu estou indo apenas para limpar o banco de dados e, em seguida,
deixá-lo com um banco de dados vazio para que possamos ir para
o próximo exercício onde nós podemos novamente
executar tipo semelhante de operações para verificar isso.
Este toma, como segundo parâmetro,
uma função de retorno de chamada que retorna um erro ou um resultado.
Dentro disso, verificamos e certificamo-nos de que a afirmação não é nula,
e então diremos, cliente.close.
Então vamos fechar a conexão com o banco de dados no local.
Então, com isso, este conjunto simples de métodos nos permitem interagir com o nosso servidor,
e também nos demonstra como podemos nos comunicar com o servidor usando
os métodos que estão disponíveis através deste módulo nó MongoDB ou o driver MongoDB.
Então, aqui, você vê que primeiro realizamos uma operação de inserção.
Em seguida, após a operação de inserção, note que,
estamos fazendo a segunda operação dentro da função de retorno de chamada.
Então, isso garante que esta operação foi concluída antes de você fazer a próxima.
Então, esta é uma segunda chamada que é fechada dentro da primeira função de retorno de chamada,
e, em seguida, correspondentemente, dentro dela.
Estamos novamente chamando os métodos aqui e lá dentro.
Então, você vê que há um aninhamento dessas chamadas,
uma dentro da outra.
Observe a estrutura porque eu vou voltar para
explicar algo sobre isso em um dos exercícios posteriores.
Então, note que, aninhamento dessas chamadas uma dentro da outra.
Vamos salvar as alterações
e, em seguida, ver o que este aplicativo faz quando executá-lo.
Voltando para o terminal, novamente,
certifique-se de que seu servidor MongoDB está funcionando, e assim,
quando ele está executando ele vai imprimir um monte de mensagens de log no console.
Podemos ignorar as mensagens de registro por enquanto.
Vamos executar o aplicativo de nó.
Então, vamos dizer, npm start,
e quando o aplicativo nó é executado,
você percebe o que faz aplicativo nó está fazendo.
Então ele diz, conectado corretamente ao servidor, Após Inserir,
então ele mostra que
este documento específico foi inserido em nosso MongoDB e o nó em particular,
o ID dado aqui.
Então, observe que isso não diz que este é um ID de objeto.
Esse ID é inserido automaticamente
pelo driver Mongo nó em seu documento quando
você tenta inseri-lo no servidor MongoDB aqui.
Esse formato é exatamente o mesmo que o ID do objeto que vimos.
Depois disso, realizamos uma operação de busca.
Então, isso é encontrado,
e então ele imprime este item aqui.
Note que a partir do exercício anterior,
tínhamos deixado no documento anterior que tínhamos inserido no exercício anterior.
Então, isso ainda é visto na coleção aqui,
e no novo documento que acabamos de inserir aqui.
Este documento é visto logo abaixo que aqui,
mas note que estes dois têm dois IDs diferentes.
Este ID corresponde ao ID do documento que acabamos de inserir.
Então, isso é sobra do exercício anterior.
Depois disso, é claro que deixamos cair a coleção para que
todo este conjunto de documentos e a coleção de pratos sejam removidos do nosso banco de dados.
Então, agora nosso banco de dados estará limpo e vazio.
Então, isso demonstra a você como podemos usar
o driver MongoDB para se comunicar a partir do nosso aplicativo nó com o servidor.
Agora que temos nossa aplicação,
deixe-me apresentar um.gitignore
aqui e, em seguida, colocar módulos de nó no o.gitignore,
e você rapidamente entender por que eu estou fazendo isso.
Em seguida, vamos voltar e inicializar o repositório Git e, em seguida, fazer um git commit.
Voltando para o terminal,
deixe-me inicializar o repositório Git,
e então, vamos verificar o status do Git e você verá que existem alguns arquivos não confirmados.
Então deixe-me verificá-los em e, em seguida, fazer um git commit com a mensagem,
Node MongoDB Exemplo um.
Esta é a parte um do exercício,
então vamos apenas verificar os itens em nosso repositório git.
Isso completa este exercício.
Neste exercício, vimos como instalamos o módulo de nó,
o driver MongoDB, então,
fomos capazes de se comunicar com o nosso servidor MongoDB de dentro do
nosso aplicativo nó usando os métodos que são fornecidos pelo driver MongoDB.
Continuaremos com este exercício na próxima parte
do exercício, onde exploraremos mais alguns métodos do piloto MongoDB.