Neste exercício, vamos continuar com o exercício anterior onde
desenvolvemos a interação entre o aplicativo nó e o servidor MongoDB.
Neste exercício, vou encapsular algumas
das operações de banco de dados em um módulo de nó próprio,
um módulo de nó baseado em arquivo
e, em seguida, fazer uso dele dentro do meu aplicativo de nó para interagir com o servidor.
Ao mesmo tempo, realizaremos várias operações
no servidor para demonstrar que seremos capazes de
interagir com o servidor usando nosso aplicativo de nó e o driver MongoDB nó.
Para começar, vamos para o nosso projeto
e, em seguida, criar um novo arquivo chamado operations.js.
Este arquivo irá encapsular todas as operações de banco de dados,
as quatro operações que eu vou executar inserir,
localizar, remover e atualizar um documento no meu banco de dados.
Agora, isso será organizado como um módulo de nó baseado em arquivo,
que então eu vou fazer uso dele no meu aplicativo nó para acessar o servidor.
Então, para começar,
deixe-me primeiro exigir assert,
neste módulo de nó,
e como isso acontece a ser um módulo de nó,
estaremos exportando vários métodos do módulo de nó.
O primeiro método seria inserir documento obviamente como você esperaria,
e isso levará quatro parâmetros DB,
o MongoDB, conexão de banco de dados dentro do meu aplicativo nó,
que eu obterei dentro do aplicativo nó.
Em seguida, o segundo é o documento que eu quero inserir.
O terceiro parâmetro é a coleção na qual eu quero inserir o documento.
A última é uma função de retorno de chamada,
que será chamada de volta assim que a operação for concluída.
Então vamos fechar a função aqui,
e isso essencialmente encapsula o método de inserção de documento aqui.
Então, esta é uma função que é exportada por este módulo nó aqui.
Agora, eu também vou incorporar mais alguns métodos aqui.
O segundo seria encontrar documentos.
Não apenas um, mas vários documentos.
Isto eu iria procurar a coleção e encontrar todos os documentos que estão na coleção.
Então, é por isso que eu só estou tomando o banco de dados
e a coleção como os dois parâmetros junto com o retorno de chamada.
A terceira função que vou implementar uma exportação daqui é o removedocument.
Isso suporta a operação de exclusão,
e assim o nome do documento levará o banco de dados,
o documento, a coleção e o retorno de chamada como os quatro parâmetros,
e vamos chamar o retorno de chamada quando a operação for concluída.
O último é, naturalmente, actualizar o documento.
Agora, é claro, você não precisa necessariamente fazer isso dessa maneira.
Eu só senti que esta seria outra maneira de ilustrar como você pode
encapsular essas funções em seu próprio módulo de nó.
Isso é apenas reorganizar o código de uma forma que é mais fácil de usar.
Assim, para as exportações,
para o documento de atualização leva o DB,
alguma forma de identificar o documento como um segundo parâmetro.
O terceiro parâmetro é a atualização,
e o quarto parâmetro é a coleção na qual
este documento existe e o retorno de chamada.
Então, quatro funções a serem exportadas pelo arquivo operations.js.
Agora, dentro dessas funções,
vamos implementar um por um.
No documento inserir,
a primeira coisa que eu vou fazer é dizer
coleção const e ele vai dizer coleção DB,
eo parâmetro é a coleção.
Então, vamos procurar a coleção lá.
Agora, isso tem que ser realizado em todos os quatro métodos.
Então, eu vou ir e colar este código em todos os quatro métodos aqui,
porque essa é uma função que eu preciso em todos eles.
Então, assim que eu conseguir a coleção,
então como você se lembra do exercício anterior,
eu posso realizar operações na coleção.
Então, eu vou dizer coleção, inserir,
e isso leva como o primeiro parâmetro o documento a ser inserido,
e o segundo parâmetro é o retorno de chamada com o erro e esse resultado.
Então, agora quando este documento
é inserido chamando o método de inserção na coleção de banco de dados,
o método de inserção deixe-me lembrá-lo,
é suportado pelo driver MongoDB.
Então, esse é o método que estamos usando aqui,
ou essa é a função que estamos usando aqui.
Agora, a primeira coisa que eu vou verificar para isso, assertequal err, nulo.
Então, eu quero ter certeza de que eu não tenho um erro.
Então eu quero ter certeza de que o erro é nulo.
Se não for nulo,
isso irá imprimir as informações e, em seguida, sair do aplicativo.
Neste momento, eu sinto que isso é bom para lidar com isso que mais tarde,
vamos ver como podemos ter uma maneira global de lidar com todos os erros quando
implementamos na próxima lição outra maneira de acessar o banco de dados MongoDB.
Agora, depois que eu fizer isso,
eu vou implementar,
eu vou simplesmente registrar essa informação.
Então eu vou dizer, log do console e inseri-lo.
Então, esta informação será impressa na tela aqui, inserida.
Agora, novamente, lembre-se dos ponto-e-vírgula e todos os que são
importantes, não se esqueça deles quando você estiver digitando seu código.
Então, eu vou dizer resultado inserido.
Este objeto de resultado que é retornado,
terá sobre ele uma propriedade chamada de propriedade result,
e esta propriedade conterá um valor.
Esta propriedade de resultado também é um objeto JavaScript,
e isso irá conter uma propriedade n que nos diz quantos documentos foram inseridos.
Então essa é a informação que eu vou imprimir aqui,
e então vamos para a próxima linha e
dizer “documentos para a coleção”.
Agora, esta é apenas uma maneira de informar o usuário que esta operação ocorreu corretamente,
e então eles vão passar esse resultado de volta para a nossa função de chamada.
Então, vamos chamar o retorno de chamada e, em seguida, o resultado será o parâmetro para o retorno de chamada.
Então, quando implementamos o uso desta função em nosso arquivo index.js,
estaremos fornecendo o retorno de chamada lá que
receberá o resultado como o parâmetro de entrada.
Então, isso é para o “InsertDocument”.
Agora, para o “FindDocument
”, o que eu vou fazer é dizer,
“col.find” e eu vou encontrar todos os documentos.
Então, é por isso que eu vou dar um objeto JavaScript vazio aqui,
que irá coincidir com todos os documentos na coleção e então eu vou dizer,
“toArray” e isso vai tomar como parâmetro uma função de callback,
e dentro dessa função de callback, é claro,
eu vou afirmar que isso não é nulo,
e então diremos, “docs de retorno de chamada.”
Vamos simplesmente passar de volta os documentos recuperados de volta para a função de chamada.
Agora, para o “RemoveDocument”, eu vou dizer, “coleção DeleteOne”.
Então, vou tentar encontrar o primeiro documento que
corresponde ao que especificamos e, em seguida, excluí-lo.
E então isso levará, novamente,
uma função de retorno de chamada como um segundo parâmetro,
e dentro dessa função de retorno de chamada,
a primeira coisa que eu verifico é certificar-se de que o erro não é nulo.
E depois disso, diremos:
“O registro do console removeu o documento vírgula do documento.”
Nós usamos a vírgula aqui porque este é um objeto JavaScript então,
se você especificar log console como este,
o documento será impresso e, em seguida, vamos passar
esse resultado de volta através da função callback.
E, finalmente, para a atualização, vamos colar.UpdateOne.
Este é um método que o driver MongoDB suporta.
Então, eu vou dizer, “Update.one document
”, e o segundo parâmetro é onde
vamos passar nos campos que precisam ser atualizados.
E do jeito que é feito,
vamos dizer, “atualização de dois pontos do dólar.”
Então, isso levará as informações de atualização que
estou enviando e, em seguida, passará para o Update.One.
O primeiro é o documento que precisa ser atualizado.
O segundo é quais campos do documento precisam ser atualizados aqui.
E o terceiro parâmetro é nulo,
e esse último parâmetro é uma função de retorno de chamada,
que obviamente nos dará o resultado da operação.
Então, a primeira coisa que eu vou verificar para ter certeza de que o erro não é nulo.
Em seguida, eu vou fazer um “log do console atualizado o documento com.”
Agora, novamente, os logs do console são puramente para nós para
garantir que o código está fazendo o que está fazendo.
Não ajuda de forma alguma.
Isto é só para nossa própria informação.
Em um servidor de produção,
você não estaria tendo esses logs de console, talvez.
Você pode desativá-los. Então, é isso.
Portanto, quatro métodos que estão sendo suportados neste módulo de nó baseado em arquivo específico inserir,
localizar, remover e atualizar.
Então, agora que implementamos este módulo de nó baseado em arquivo,
vamos para o arquivo index.js
e, em seguida, para fazer uso desse módulo de nó baseado em arquivo,
eu preciso exigir isso aqui.
Então, eu vou dizer, “Const dboper requer.”
Uma vez que este é um módulo de nó baseado em arquivo, você obtém o caminho completo para o módulo de nó,
e que neste caso acontece a ser. /operações
porque ele está na mesma pasta que o meu arquivo index.js.
Agora, uma vez que tenhamos feito isso,
então bem aqui, esta função,
este código que estávamos fazendo para acessar o banco de dados agora inserir,
estaremos usando o dboper que acabamos de implementar para acessar esse banco de dados.
Então, vamos dizer, “dboper insert document,
" e este “insert document” leva o db como o primeiro parâmetro.
O banco de dados aqui, é este banco de dados que veio quando chamamos MongoClient connect.
Assim que o banco de dados será passado, assim,
meu módulo de nó de operações sabe onde acessar o banco de dados.
Em seguida, o segundo parâmetro é o,
então se você olhar para o “inserir documento” você verá
que o segundo parâmetro é o documento a ser inserido.
Então, eu vou dizer, “nome. “
Eu estou indo apenas para construir um objeto JSON ou JavaScript objeto aqui,
que será automaticamente mapeado em objeto adjacente quando ele está sendo inserido.
E o terceiro parâmetro, como você vê,
“coleção de documentos de banco de dados e retorno de chamada.”
Então o terceiro parâmetro é a coleção e a coleção é
a coleção de pratos e o final é o callback.
A chamada de volta novamente quando você se lembra recebe o resultado.
Se você olhar para trás para o bebê implementou o documento de inserção,
o retorno de chamada recebeu o resultado como o parâmetro.
Então, dentro deste callback, vamos lidar com esse valor de resultado aqui.
Então, quando o valor do resultado vem em nós vamos fazer um console.log.
Vamos dizer inserir
barra invertida do documento N e vamos dizer resultado OPS.
O OPS informa o número de operações de inserção que foram realizadas.
Então este é outro objeto que vai estar no
objeto JavaScript resultado que é passado de volta como
o parâmetro e então eu vou apenas imprimir esse valor.
Então isso nos dará algumas informações sobre o que aconteceu.
Agora, uma vez que isto seja concluído,
dentro desta função de retorno eu vou chamar a próxima operação de banco de dados.
Então eu vou dizer dboper e depois encontrar os documentos.
Então eu vou dizer dbmeals e o terceiro parâmetro é docs,
que é a função callback.
Quando eu receber os documentos, vou fazer um
console.log dizendo documentos encontrados,
e simplesmente bloquearemos os documentos na tela.
Então, isso imprimirá os documentos encontrados.
Observe que esta chamada está dentro
da função de retorno que é aplicada para a chamada de função anterior, de
modo que é algo que eu quero que você observe especificamente.
Agora, novamente dentro desta chamada de função eles precisam fazê-lo desta maneira porque até que
este callback seja chamado não podemos fazer a próxima operação.
Então, nessa próxima operação, vou atualizar o documento que acabei de inserir.
Então eu vou dizer atualizar o documento e eu vou dizer Atualizar Documento DB,
e, em seguida, o próximo parâmetro é o documento
e eu não preciso especificar o documento inteiro Eu só posso especificar um campo e, em
seguida, que vai encontrar o documento que corresponde a este campo particular.
O que eu vou fazer é o próximo parâmetro é a atualização que precisa ser fornecida.
Então, a atualização é qual campo eu quero atualizar,
então eu vou atualizar
o campo de descrição dizendo Updated Test,
e então o quarto é a coleção que é Dates,
e o final é a função callback que obtém
os documentos como o valor de retorno ou
melhor resultado da operação de atualização que acabamos de realizar.
Em seguida, dentro desta função de retorno de chamada,
eu vou fazer novamente um console.log dizendo
atualizado documento barra invertida N. O documento atualizado será passado de
volta em result.result
nesta propriedade do objeto de resultado que é passado rastreamento.
Novamente, observe como as chamadas estão sendo aninhadas
dentro das funções de retorno de chamada aqui.
Quero que notem esta estrutura do código
especificamente porque é para isso que vou voltar no próximo exercício.
Agora depois que eu fizer isso,
eu vou encontrar os documentos,
então deixe-me apenas copiar isso e então eu vou usar o mesmo código aqui.
Então eu vou dizer, encontrar documentos.
Dentro aqui eu vou novamente dizer, encontrado documento atualizado.
Então, finalmente, quando eu terminar com isso,
eu vou simplesmente chamar coleção drop db.
Então eu vou excluir esta coleção de pratos para que eu
vou limpar meu banco de dados para que eu não tenha
mais nada porque para o próximo exercício eu quero limpar
o banco de dados e, em seguida, começar com um banco de dados mais limpo.
Então, eu vou limpar
a coleção de pratos e, em seguida, isso resultaria em um retorno de chamada.
Então, dentro aqui eu vou fazer um ditado console.log,
coleção caiu, e então eu vou apenas imprimir o resultado que entrou.
Então, finalmente, feche o banco de dados.
Observe que a estrutura do código,
DB inserir documento e dentro da função callback eu vou chamar
a próxima função e dentro
do callback off que eu vou chamar
a próxima função e dentro da próxima função de callback e assim por diante.
Então, você vê um conjunto aninhado de retornos de chamada aqui e
um conjunto estruturado de árvore aninhado de retorno de chamada aqui.
Isso é algo que eu quero que você preste atenção.
Vamos salvar as alterações e ir e olhar para esta versão do nosso aplicativo.
Voltando ao terminal,
deixe-me executar o aplicativo.
Então deixe-me digitar NPM start e veremos esse resultado.
Agora, a partir deste resultado você pode ver que o documento está
inserido na coleção e que é o documento que foi encontrado.
Na segunda etapa,
estamos encontrando o documento para quando chamamos o documento DB find,
então este é o documento que é recuperado da minha coleção.
Então eu peço a ele para atualizar o documento com
isso e então você vai notar que ele diz documento atualizado e, em seguida,
aqui ele imprime o resultado ou OPS e ele diz N é igual a
um número modificado como um e estava tudo bem.
Em seguida, ele imprime o documento atualizado,
encontramos o documento atualizado aqui e isso é o que é impresso aqui,
e note em particular que a descrição foi atualizada.
Então, finalmente, ele deixou cair a coleção.
Então, vemos como este aplicativo é executado e é capaz de fazer uso
do módulo nó que implementamos e, em seguida, executou várias operações de banco de dados.
Com isso, completamos este exercício.
Neste exercício eu tenho demonstrado a você como você iria interagir com
o seu servidor MongoDB a partir de seu aplicativo nó.
Nós implementamos nosso próprio módulo de nó aqui e, em seguida, usá-lo
dentro da nossa aplicação nó, encapsulando
certas operações de banco de dados nesse módulo nó.
Este é um bom momento para você fazer um commit Git com
o nó de mensagem MongoDB exemplo parte dois.