Introdução ao MongoDB e Java – Tutorial de operações CRUD

Você pode definir o com.MongoDB.Propriedade da WriteConcern que o Mongotemplate usará para operações de gravação se ainda não tiver sido especificado através do driver em um nível mais alto, como COM.MongoDB.Mongo. Se a propriedade WriteConcern da Mongotemplate não estiver definida, ela será padrão para o conjunto no banco de dados do driver do MongoDB ou na configuração de coleção.

Resumo

Neste tutorial, exploraremos como começar com MongoDB e Java. Abordaremos as operações básicas do CRUD (Criar, Read, Atualizar, Excluir) usando o driver Java e os dados da mola do MongoDB MongoDBB.

Pontos chave:

1. O suporte do MongoDB para Java inclui uma ampla gama de recursos.
2. Spring fornece suporte de configuração para o MongoDB usando as classes @configuration baseadas em Java ou um espaço de nome XML.
3. A classe Mongotemplate é uma utilidade útil para executar operações comuns do MongoDB e mapeamento de objetos entre documentos e pojos.
4. A tradução de exceção para a hierarquia de exceção de acesso por dados portáteis da Spring é suportada.
5. O serviço de conversão da Spring se integra ao mapeamento de objetos rico em recursos do MongoDB.
6. Os metadados de mapeamento baseados em anotação estão disponíveis e podem ser estendidos para apoiar outros formatos.
7. Persistência e mapeamento de eventos do ciclo de vida são suportados.
8. Consulta, critérios e DSLs de atualização baseados em Java são fornecidos.
9. A implementação automática de interfaces de repositório é suportada, incluindo métodos de localizador personalizado.
10. A integração de Querydsl permite consultas seguras de tipo.
11. A persistência entre lojas é suportada, permitindo que as entidades JPA sejam persistidas/recuperadas usando o MongoDBB.
12. Um Appender Log4J Log é fornecido para a integração do MongoDB.
13. A integração geoespacial está disponível para trabalhar com dados geoespaciais.

Questões:

1. Q1: Quais recursos o MongoDB suporta para Java?

A1: o suporte do MongoDB para Java inclui uma ampla gama de recursos, como suporte de configuração da mola, mapeamento de objetos, tradução de exceção e muito mais.

2. Q2: Como podemos configurar o MongoDB na primavera?

A2: MongoDB pode ser configurado na primavera usando aulas de @configuration baseadas em Java ou um namespace XML.

3. Q3: Qual é a classe Mongotemplate usada para?

A3: A classe Mongotemplate é uma classe auxiliar que aumenta a produtividade, realizando operações comuns do MongoDB e fornecendo mapeamento de objetos entre documentos e pojos.

4. Q4: Como a primavera lida com exceções nas operações do MongoDBB?

A4: Spring traduz exceções em sua hierarquia de exceção de acesso por dados portáteis.

5. Q5: a integração do MongoDB com o mapeamento de objetos de suporte da mola?

A5: Sim, a integração do MongoDB com a primavera inclui mapeamento de objetos rico em recursos integrados ao serviço de conversão da Spring.

6. Q6: O MongoDB pode suportar outros formatos de metadados?

A6: Sim, os metadados de mapeamento baseados em anotação em MongoDB podem ser estendidos para apoiar outros formatos de metadados.

7. Q7: O MongoDB suporta a persistência e o mapeamento de eventos do ciclo de vida?

A7: Sim, o MongoDB suporta persistência e mapeamento de eventos do ciclo de vida.

8. Q8: Qual é a vantagem de usar consulta, critérios e atualizações baseados em Java no MongoDB?

A8: Consulta, Critérios e DSLs de Atualização baseados em Java fornecem uma maneira mais conveniente e conveniente de criar consultas e atualizar operações no MongoDBB.

9. Q9: Spring pode implementar automaticamente os métodos de localizador personalizado em interfaces de repositório?

A9: Sim, a primavera pode implementar automaticamente métodos de localizador personalizado em interfaces de repositório.

10. Q10: Qual é o benefício da integração de Querydsl em MongoDB?

A10: A integração de Querydsl no MongoDB permite consultas seguras de tipo.

11. Q11: O MongoDB pode ser usado para persistência entre lojas?

A11: Sim, o MongoDB suporta persistência de lojas, permitindo que as entidades JPA sejam persistidas/recuperadas usando o MongoDBB.

12. Q12: MongoDB fornece um Appender Log4J Log?

A12: Sim, o MongoDB fornece um Appender Log4J para integração com log4j.

13. Q13: O MongoDB suporta dados geoespaciais?

A13: Sim, o MongoDB fornece integração para trabalhar com dados geoespaciais.

Começando

Para começar com o suporte do MongoDB da primavera, você precisará de MongoDB 1.4 ou superior e Java SE 5 ou superior. Recomenda -se usar o último lançamento de produção (2.0.x até o momento da redação).

Siga estas etapas para configurar um ambiente de trabalho:

1. Configure um servidor MongoDB em execução. Consulte o guia de início rápido do MongoDB para obter instruções sobre como iniciar uma instância do MongoDB.
2. Crie um projeto baseado em primavera no STS (Spring Tool Suite) ou qualquer outro ambiente de desenvolvimento integrado (IDE).
3. Inclua a dependência do MongoDB dos dados da primavera no POM do seu projeto.Arquivo XML:

        <dependência>
            <grupo>org.Springframework.dados</groupID>
            <Artifactid>Spring-Data-Mongodb</Artifactid>
            <versão>1.1.0.LIBERAR</versão>
        </dependência>
    

4. Certifique -se de ter a versão correta do Spring especificada em seu pom.xml:

        <propriedades>
            <primavera.versão>3.1.2.LIBERAR</primavera.versão>
        </Propriedades>
    

5. Adicione o repositório de marco da primavera ao seu pom.xml:

        <Repositórios>
            <repositório>
                <eu ia>Milestão de primavera</eu ia>
                <nome>Repositório de Milestone da Spring Maven</nome>
                <url>http: // repo.Springsource.Org/Libs-Milestone</url>
            </repositório>
        </repositórios>
    

6. Defina o nível de log4j de log4j para depurar no log4j.Arquivo de propriedades:

        log4j.categoria.org.Springframework.dados.documento.MongoDB = Debug
        log4j.Appender.stdout.layout.Conversãopattern = %d %5p %40.40c:%4l -%m%n
    

7. Crie uma aula de pessoa simples para persistir:

        pacote org.primavera.MongoDB.exemplo;
        Pessoa da classe pública {
            ID de string privado;
            nome de string privado;
            private Int Age;
            Pessoa pública (nome da string, Int Age) {
                esse.nome = nome;
                esse.idade = idade;
            }
            public String getId () {
                ID de retorno;
            }
            public String getName () {
                Nome de retorno;
            }
            public int getage () {
                idade de retorno;
            }
            @Sobrepor
            public string tostring () {
                retornar "pessoa [id =" + id + ", nome =" + nome + ", idade =" + idade + "]";
            }
        }
    

8. Crie um aplicativo principal para executar:

        pacote org.primavera.MongoDB.exemplo;
        importar org estático.Springframework.dados.MongoDB.essencial.consulta.Critério.onde;
        importação org.apache.Comuns.exploração madeireira.Registro;
        importação org.apache.Comuns.exploração madeireira.LogFactory;
        importação org.Springframework.dados.MongoDB.essencial.Mongoooperações;
        importação org.Springframework.dados.MongoDB.essencial.Mongotemplate;
        importação org.Springframework.dados.MongoDB.essencial.consulta.Consulta;
        importar com.MongoDB.Mongo;
        classe pública MongoApp {
            log de log estático privado = logFactory.GetLog (Mongoapp.aula);
            public static void main (string [] args) lança exceção {
                MongoooPerations Mongoops = New Mongotemplate (New Mongo (), "Database");
                Mongoops.inserir (nova pessoa ("Joe", 34));
                registro.Informações (Mongoops.FindOne (nova consulta (onde ("Nome").é ("joe")), pessoa.aula));
            }
        }
    

Introdução ao MongoDB e Java – Tutorial de operações CRUD

Você pode definir o com.MongoDB.Propriedade da WriteConcern que o Mongotemplate usará para operações de gravação se ainda não tiver sido especificado através do driver em um nível mais alto, como COM.MongoDB.Mongo . Se a propriedade WriteConcern da Mongotemplate não estiver definida, ela será padrão para o conjunto no banco de dados do driver do MongoDB ou na configuração de coleção.

MongoDB suporta java

O suporte do MongoDB contém uma ampla gama de recursos que estão resumidos abaixo.

• Suporte de configuração da mola usando classes @configuration baseadas em Java ou um espaço de nome XML para uma instância do driver mongo e conjuntos de réplicas
• Classe auxiliar de Mongotemplate que aumenta a produtividade executando operações comuns de mongono. Inclui mapeamento de objetos integrados entre documentos e pojos.
• Tradução de exceção para a hierarquia de exceção de acesso por dados portáteis da primavera
• Recurso rico em mapeamento de objetos integrados ao serviço de conversão da Spring
• Metadados de mapeamento baseados em anotação, mas extensível para apoiar outros formatos de metadados
• Persistência e Mapeamento de eventos do ciclo de vida
• Consulta baseada em Java, critérios e DSLs de atualização
• Implementação automática de interfaces repositivas, incluindo suporte para métodos de localizador personalizado.
• Integração de Querydsl para oferecer suporte a consultas seguras de tipo.
• Persistência entre lojas – Suporte para entidades JPA com campos persistiu/recuperado transparentemente usando o MongoDBB
• Log4j log Appender
• Integração geoespacial

Para a maioria das tarefas, você se encontrará usando o Mongotemplate ou o suporte do repositório que alavancam a rica funcionalidade de mapeamento. Mongotemplate é o lugar para procurar acessar a funcionalidade, como contadores de incrementação ou operações ad-hoc crud. O Mongotemplate também fornece métodos de retorno de chamada para que seja fácil obter os artefatos de API de baixo nível, como Org.Mongo.DB para se comunicar diretamente com o MongoDB. O objetivo de nomear convenções em vários artefatos de API é copiar aqueles no driver Java Base MongoDB para que você possa facilmente mapear seu conhecimento existente nas APIs da primavera.

5.1 Introdução

O suporte do MongoDB da primavera requer MongoDB 1.4 ou superior e Java SE 5 ou superior. O último lançamento de produção (2.0.x até o momento da redação) é recomendado. Uma maneira fácil de inicializar a criação de um ambiente de trabalho é criar um projeto baseado em primavera no STS.

Primeiro você precisa configurar um servidor MongoDB em execução. Consulte o guia de início rápido do MongoDB para obter uma explicação sobre como iniciar uma instância do MongoDB. Uma vez instalado, o início do MongoDB é normalmente uma questão de executar o seguinte comando: Mongo_home/bin/MongoD

Para criar um projeto de primavera no STS, vá para o arquivo -> Novo -> Projeto de modelo de primavera -> Projeto Simple Spring Utility -> Pressione Sim quando solicitado. Em seguida, insira um projeto e um nome de pacote como org.primavera.MongoDB.exemplo.

Em seguida, adicione o seguinte ao POM.Seção de dependências XML.

    org.Springframework.dados Spring-Data-Mongodb 1.1.0.LIBERAR  

Também mude a versão da primavera no pom.xml para ser

 3.1.2.LIBERAR 

Você também precisará adicionar a localização do repositório de marco da primavera para maven ao seu pom.XML, que está no mesmo nível do seu elemento

   Milestão de primavera Repositório de Milestone da Spring Maven http: // repo.Springsource.Org/Libs-Milestone  

O repositório também é navegável aqui.

Você também pode definir o nível de registro para depurar para ver algumas informações adicionais, edite o log4j.arquivo de propriedades para ter

log4j.categoria.org.Springframework.dados.documento.MongoDB = Debug Log4J.Appender.stdout.layout.Conversãopattern = %d %5p %40.40c:%4l -%m%n

Crie uma aula de pessoa simples para persistir

pacote org.primavera.MongoDB.exemplo; público aula Pessoa < privado ID da string; privado Nome da string; privado int idade; público Pessoa (nome da string, int idade) < esse.nome = nome; esse.idade = idade; > público String getId () < retornar eu ia; > público String getName () < retornar nome; > público int getage () < retornar idade; > @Sobrepor público String ToString () < retornar "Pessoa [id hl-string"> ", nome hl-string"> ", idade hl-string"> "]"; >>

E um aplicativo principal para executar

pacote org.primavera.MongoDB.exemplo; importar estático org.Springframework.dados.MongoDB.essencial.consulta.Critério.onde; importar org.apache.Comuns.exploração madeireira.Registro; importar org.apache.Comuns.exploração madeireira.LogFactory; importar org.Springframework.dados.MongoDB.essencial.Mongoooperações; importar org.Springframework.dados.MongoDB.essencial.Mongotemplate; importar org.Springframework.dados.MongoDB.essencial.consulta.Consulta; importar com.MongoDB.Mongo; público aula MongoApp < privado estático final Log log = logFactory.GetLog (Mongoapp.aula); público estático vazio principal (string [] args) joga Exceção < MongoOperations mongoOps = novo Mongotemplate (novo Mongo (), "base de dados"); Mongoops.inserir(novo Pessoa("Joe", 34)); registro.Informações (Mongoops.FindOne (novo Consulta (onde ("nome").é("Joe")), Pessoa.aula)); Mongoops.Dropcollection ("pessoa"); >>

Isso produzirá a seguinte saída

10: 01: 32.062 APACAÇÃO DE DEBUG.MongopersistentityIndexCreator: 80 - Analisando a classe de classe Org.primavera.exemplo.Pessoa para informações de índice. 10: 01: 32.265 Debug Ramework.dados.MongoDB.essencial.Mongotemplate: 631 - Insira DBObject Contendo campos: [_class, idade, nome] Na coleção: Pessoa 10: 01: 32.765 Ramework Ramework.dados.MongoDB.essencial.Mongotemplate: 1243 - FindOne usando consulta: < "name" : "Joe">em db.Coleção: banco de dados.Pessoa 10: 01: 32.953 Info Org.primavera.MongoDB.exemplo.MongoApp: 25 - Pessoa [ID = 4DDBBA3C0BE56B7E1B210166, Nome = Joe, idade = 34] 10: 01: 32.984 Debug Ramework.dados.MongoDB.essencial.Mongotemplate: 375 - Coleção descartada [banco de dados.pessoa]

Mesmo neste exemplo simples, há poucas coisas para perceber

• Você pode instanciar a classe Central Helper de Spring Mongo, Mongotemplate, usando o com.MongoDB.Objeto Mongo e o nome do banco de dados para usar.
• O mapeador trabalha contra objetos POJO padrão sem a necessidade de metadados adicionais (embora você possa opcionalmente fornecer essas informações. Veja aqui.).
• As convenções são usadas para lidar com o campo de identificação, convertendo -o para ser um objectId quando armazenado no banco de dados.
• As convenções de mapeamento podem usar o acesso de campo. Observe que a aula da pessoa tem apenas getters.
• Se os nomes dos argumentos do construtor corresponderem aos nomes de campo do documento armazenado, eles serão usados ​​para instanciar o objeto

5.2 Exemplos repositórios

Há um repositório do GitHub com vários exemplos que você pode baixar e brincar para ter uma ideia de como a biblioteca funciona.

5.3 Conectando -se ao MongoDB com a primavera

Uma das primeiras tarefas ao usar o MongoDB e a primavera é criar um COM.MongoDB.Objeto Mongo usando o contêiner do IOC. Existem duas maneiras principais de fazer isso, usando metadados de feijão baseados em java ou metadados de feijão baseados em XML. Estes são discutidos nas seções a seguir.

Para aqueles que não estão familiarizados com a configuração do recipiente de mola usando metadados de feijão baseados em Java, em vez de metadados baseados em XML, veja a introdução de alto nível nos documentos de referência aqui, bem como a documentação detalhada aqui.

5.3.1 Registrando uma instância de Mongo usando metadados baseados em Java

Um exemplo de uso de metadados de feijão baseados em Java para registrar uma instância de um COM.MongoDB.Mongo é mostrado abaixo

Exemplo 5.1. Registrando um com.MongoDB.Objeto Mongo usando metadados de feijão baseado em Java

@Configuração público aula AppConfig < / * * Use a API de driver Mongo padrão para criar um COM.MongoDB.Instância de Mongo. */ público @Feijão Mongo Mongo () joga UnknownHostException < retornar novo Mongo ("Localhost"); >>

Esta abordagem permite que você use o com.MongoDB.API Mongo que você já pode estar acostumado a usar, mas também polui o código com a exceção do desconhecida. O uso da exceção verificada não é desejável, pois os metadados de feijão baseados em Java usa métodos como um meio de definir dependências de objetos, tornando o código de chamada desordenado.

Uma alternativa é registrar uma instância de COM.MongoDB.Instância de Mongo com o contêiner usando o MongofactoryBean de Spring . Em comparação com instantar um COM.MongoDB.Instância de Mongo diretamente, a abordagem FactoryBean não lança uma exceção verificada e tem a vantagem adicional de também fornecer ao contêiner uma implementação excepcionária de translator que traduz exceções de MongoDB para exceções na hierarquia portátil da Spring DataAccessception para as classes de acesso a dados anotadas com a @repositório anual. Esta hierarquia e uso do @repository são descritos nos recursos de suporte da Spring Dao.

Um exemplo de um metadado de feijão baseado em Java que suporta a tradução de exceção nas classes anotadas @repository é mostrada abaixo:

Exemplo 5.2. Registrando um com.MongoDB.Objeto Mongo usando o MongofactoryBean da Spring e permitindo o suporte à tradução de exceção da Spring

@Configuração público aula AppConfig < / * * Bean de fábrica que cria o COM.MongoDB.Instância de Mongo */ público @Feijão Mongo de MongofactoryBean () < MongoFactoryBean mongo = novo MongofactoryBean (); Mongo.Sethost ("Localhost"); retornar Mongo; >>

Para acessar o COM.MongoDB.Objeto Mongo Criado pelo MongofactoryBean em outras @Configuration ou suas próprias aulas, use um “campo privado @Autowired Mongo Mongo;” Campo.

5.3.2 Registrando uma instância de Mongo usando metadados baseados em XML

Enquanto você pode usar o espaço de nome XML tradicional de Spring para registrar uma instância de COM.MongoDB.Mongo com o contêiner, o XML pode ser bastante detalhado, pois é um propósito geral. Namespaces XML são uma alternativa melhor para configurar objetos comumente usados, como a instância do Mongo. O espaço para nome de Mongo ALAWS VOCÊ para criar um local de servidor de instâncias, réplicas e opções do Mongo Instância.

Para usar os elementos de namespace mongo, você precisará fazer referência ao esquema Mongo:

Exemplo 5.3. Esquema XML para configurar o MongoDB

  xmlns="http: // www.Springframework.org/esquema/feijão " xmlns: xsi="http: // www.W3.org/2001/xmlschema-instância " xmlns: contexto="http: // www.Springframework.org/esquema/contexto " XMLNS: Mongo="http: // www.Springframework.org/esquema/dados/mongo " XSI: esquema= "http: // www.Springframework.org/esquema/contexto http: // www.Springframework.org/esquema/context/spring-Context-3.0.xsd http: // www.Springframework.org/schema/data/mongo http: // www.Springframework.org/esquema/dados/mongo/spring-mongo-1.0.xsd http: // www.Springframework.org/esquema/feijão http: // www.Springframework.Org/Schema/Beans/Spring-Beans-3.0.xsd ">   

Uma configuração mais avançada com o Mongooptions é mostrada abaixo (observe que estes não são valores recomendados)

Exemplo 5.4. Esquema XML para configurar um COM.MongoDB.Objeto Mongo com Mongoopções

  hospedar="Localhost" porta="27017">  conexões por host="8" threads-arelded-to-bloqueio-para-conexão multiplier="4" Connect-timeout="1000" Max-Wait-Time="1500>" Cetrina automática de conexão="verdadeiro" Socket-Keep-Alive="verdadeiro" Socket-timeout="1500" ok escravo="verdadeiro" número de gravação="1" Write-timeout="0" Write-fsync="verdadeiro"/>   

Uma configuração usando conjuntos de réplicas é mostrada abaixo.

Exemplo 5.5. Esquema XML para configurar com.MongoDB.Objeto Mongo com conjuntos de réplicas

 eu ia="REPRICASETMONO" réplica-set="127.0.0.1: 27017, localhost: 27018 "/> 

5.3.3 a interface MongoDBFactory

Enquanto com.MongoDB.Mongo é o ponto de entrada para a API do driver MongoDB, conectando -se a uma instância específica do banco de dados MongoDB requer informações adicionais, como o nome do banco de dados e um nome de usuário e senha opcionais. Com essas informações, você pode obter um COM.MongoDB.Objeto DB e acesse toda a funcionalidade de uma instância de banco de dados MongoDB específica. A primavera fornece a organização.Springframework.dados.MongoDB.essencial.Interface MongoDBFactory mostrada abaixo para conectar a conectividade de bootstrap ao banco de dados.

público interface MongoDBFactory < DB getDb() joga DataAccessException; Db getdb (string dbname) joga DataAccessException; >

As seções a seguir mostram como você pode usar o contiainer com os metadados baseados em Java ou XML para configurar uma instância da interface MongoDBFactory. Por sua vez, você pode usar a instância MongoDBFactory para configurar o Mongotemplate.

A classe Org.Springframework.dados.MongoDB.essencial.SimpleMonGodBFactory fornece implementos da interface MongoDBFactory e é criado com um COM padrão.MongoDB.Instância de Mongo, o nome do banco de dados e uma organização opcional.Springframework.dados.autenticação.Argumento do construtor do usuário.

Em vez de usar o contêiner do IOC para criar uma instância do Mongotemplate, você pode apenas usá -los no código Java padrão, como mostrado abaixo.

público aula MongoApp < privado estático final Log log = logFactory.GetLog (Mongoapp.aula); público estático vazio principal (string [] args) joga Exceção < MongoOperations mongoOps = novo Mongotemplate (Novo SimpleMongodBFactory (New Mongo (), "Database")); Mongoops.inserir(novo Pessoa("Joe", 34)); registro.Informações (Mongoops.FindOne (novo Consulta (onde ("nome").é("Joe")), Pessoa.aula)); Mongoops.Dropcollection ("pessoa"); >>

O código em negrito destaca o uso do simplemonGodBFactory e é a única diferença entre a listagem mostrada na seção de início.

5.3.4 Registrando uma instância MongoDBFactory usando metadados baseados em Java

Para registrar uma instância MongoDBFactory com o contêiner, você escreve código como o que foi destacado na lista de códigos anterior. Um exemplo simples é mostrado abaixo

@Configuração público aula MONGOCONFIGURAÇÃO < público @Feijão MongoDBFactory MongoDBFactory () joga Exceção < retornar novo SimpleMongodBFactory (novo Mongo (), "base de dados"); >>

Para definir o nome de usuário e a senha, crie uma instância de organização.Springframework.dados.autenticação.Usercredentials e passa para o construtor, como mostrado abaixo. Esta listagem também mostra usando o MongoDBFactory Register uma instância de Mongotemplate com o contêiner.

@Configuração público aula MONGOCONFIGURAÇÃO < público @Feijão MongoDBFactory MongoDBFactory () joga Exceção < UserCredentials userCredentials = novo As credenciais do usuário("Joe", "segredo"); retornar novo SimpleMongodBFactory (novo Mongo (), "base de dados", as credenciais do usuário); > público @Feijão Mongotemplate Mongotemplate () joga Exceção < retornar novo Mongotemplate (mongodbFactory ()); >>

5.3.5 Registrando uma instância mongodbFactory usando metadados baseados em XML

O namespace mongo fornece uma maneira convencional de criar um simplemongodbFactory em comparação com o uso do espaço para nome. O uso simples é mostrado abaixo

 dbname="base de dados">

No exemplo acima, um COM.MongoDB.A instância de Mongo é criada usando o host padrão e o número da porta. O simplomanGodBFactory registrado no contêiner é identificado pelo id ‘mongodbFactory’, a menos que um valor para o atributo de identificação seja especificado.

Você também pode fornecer o host e a porta para o COM subjacente.MongoDB.Instância de Mongo, como mostrado abaixo, além de nome de usuário e senha para o banco de dados.

 eu ia="OutrongoDBFactory" hospedar="Localhost" porta="27017" dbname="base de dados" nome de usuário="Joe" senha="segredo"/>

Se você precisar configurar opções adicionais no COM.MongoDB.Instância de Mongo que é usada para criar um simplemongodbFactory, você pode consultar um feijão existente usando o atributo mongo-ref, como mostrado abaixo. Para mostrar outro padrão de uso comum, esta listagem mostra o uso de um espaço reservado para a propriedade para parametizar a configuração e criar o Mongotemplate .

 localização="Classpath:/com/myapp/mongodb/config/mongo.propriedades "/>  hospedar="$" porta="$">  conexões por host="$" threads-arelded-to-bloqueio-para-conexão multiplier="$" Connect-timeout="$" Max-Wait-Time="$" Cetrina automática de conexão="$" Socket-Keep-Alive="$" Socket-timeout="$" ok escravo="$" número de gravação="1" Write-timeout="0" Write-fsync="verdadeiro"/>   dbname="base de dados" Mongo-Ref="Mongo"/>  eu ia="Outrongotemplate" aula="Org.Springframework.dados.MongoDB.essencial.Mongotemplate ">  nome="MongoDBFactory" Ref="MongoDBFactory"/> 

5.4 Introdução ao Mongotemplate

O Mongotemplate de classe, localizado no pacote Org.Springframework.dados.documento.MongoDB, é a classe central do fornecimento de suporte do MongoDB da primavera um rico conjunto de recursos para interagir com o banco de dados. O modelo oferece operações de conveniência para criar, atualizar, excluir e consultar documentos do MongoDB e fornece um mapeamento entre seus objetos de domínio e documentos do MongoDBB.

Uma vez configurado, o Mongotemplate é seguro para threads e pode ser reutilizado em várias instâncias.

O mapeamento entre documentos do MongoDB e classes de domínio é feito delegando para uma implementação da interface Mongoconverter . A Spring fornece duas implementações, SimpleMappingConverter e MongomappingConverter, mas você também pode escrever seu próprio conversor. Consulte a seção sobre Mongocoverters para obter informações mais detalhadas.

A classe Mongotemplate implementa as mangoaperações da interface . No máximo possível, os métodos de MongoooPerações têm o nome de métodos disponíveis no objeto de coleta de driver do MongoDB, assim como tornar a API familiar aos desenvolvedores existentes do MongoDB que estão acostumados com a API do driver. Por exemplo, você encontrará métodos como “Find”, “FindandModify”, “FindOne”, “Insert”, “Remover”, “Salvar”, “Atualizar” e “Updatemulti”. O objetivo do design era facilitar a transição entre o uso do driver da base do MongoDB e das Mongoooperações . Uma grande diferença entre as duas APIs é que as mangoaperações podem ser aprovadas em objetos de domínio em vez de dbobject e há APIs fluentes para consulta, critérios e operações de atualização em vez de preencher um dbobject para especificar os parâmetros para aqueles que operam.

A maneira preferida de fazer referência às operações na instância do Mongotemplate é através de suas mangoooperações de interface .

A implementação do conversor padrão usado pelo Mongotemplate é o MongoMappingConverter. Embora o MongoMappingConverter possa usar metadados adicionais para especificar o mapeamento de objetos para documentos, também é capaz de converter objetos que não contêm metadados aditonais usando algumas convenções para o mapeamento de IDs e nomes de coleção. Essas convenções, bem como o uso das anotações de mapeamento, são explicadas no capítulo de mapeamento.

No lançamento do M2 SimpleMappingConverter, foi o padrão e essa classe agora está depreciada, pois sua funcionalidade foi subsumida pelo MongoMappingConverter.

Outra característica central do Mongotemplate é a tradução de exceção de exceções jogadas no driver Java MongoDB na hierarquia de exceção de acesso por dados portátil da Spring. Consulte a seção sobre tradução de exceção para obter mais informações.

Embora existam muitos métodos de conveniência no Mongotemplate para ajudá -lo a executar facilmente tarefas comuns se precisar acessar a API do driver MongoDB diretamente para acessar a funcionalidade não exposta explicitamente pelo Mongotemplate, você pode usar um dos vários métodos de chamada de execução para acessar as APIs de driver subjacente. Os retornos de chamada executivos lhe darão uma referência a um com.MongoDB.Coleção ou um com.MongoDB.Objeto DB. Consulte a seção de retorno de chamada de execução para obter mais informações.

Agora, vejamos exemplos de como trabalhar com o Mongotemplate no contexto do contêiner da primavera.

5.4. Mongotemplate instantante

Você pode usar o Java para criar e registrar uma instância de Mongotemplate, como mostrado abaixo.

Exemplo 5.6. Registrando um com.MongoDB.Objeto Mongo e permitindo o suporte de tradução de exceção da Spring

@Configuração público aula AppConfig < público @Feijão Mongo Mongo () joga Exceção < retornar novo Mongo ("Localhost"); > público @Feijão Mongotemplate Mongotemplate () joga Exceção < retornar novo Mongotemplate (Mongo (), "MyDatabase"); >>

Existem vários construtores sobrecarregados do Mongotemplate. Estes são

• Mongotemplate (Mongo Mongo, String DatabaseName) – pega o COM.MongoDB.Objeto Mongo e o nome do banco de dados padrão para operar contra.
• Mongotemplate (Mongo Mongo, String DatabaseName, UserCredentials UserCredentials) – adiciona o nome de usuário e a senha para autenticar com o banco de dados.
• Mongotemplate (Mongodbfactory mongodbfactory) – pega um objeto MongoDBFactory que encapsulou o COM.MongoDB.Objeto Mongo, nome do banco de dados e nome de usuário e senha.
• Mongotemplate (MongoDBFactory MongoDBFactory, Mongoconverter Mongoconverter) – Adiciona um Mongoconverter para usar no mapeamento.

Você também pode configurar um Mongotemplate usando o esquema XML da Spring.

"Localhost" porta ="27017"/> "Mongotemplate" aula="Org.Springframework.dados.MongoDB.essencial.Mongotemplate "> "Mongo"/> "nome do banco de dados" valor ="Geoespacial"/> 

Outras propriedades opcionais que você deseja definir ao criar um Mongotemplate são o padrão WriterSultCheckingPolicy, WriteConcern e ReadPreference .

A maneira preferida de fazer referência às operações na instância do Mongotemplate é através de suas mangoooperações de interface .

Política de Escritura de Writesult

Quando em desenvolvimento, é muito útil registrar ou lançar uma exceção se o COM.MongoDB.O WriterSulting retornou de qualquer operação do MongoDB contém um erro. É bastante comum esquecer de fazer isso durante o desenvolvimento e depois acabar com um aplicativo que parece ser executado com sucesso, mas na verdade o banco de dados não foi modificado de acordo com suas expectativas. Defina a propriedade WriterSultSultChecking da Mongotemplate como enumera com os seguintes valores, log, exceção ou nenhum para registrar o erro, arremesso e exceção ou não fazer nada. O padrão é usar um valor de esceca de grau de graça de nenhum.

WRITECONCERN

Você pode definir o com.MongoDB.Propriedade da WriteConcern que o Mongotemplate usará para operações de gravação se ainda não tiver sido especificado através do driver em um nível mais alto, como COM.MongoDB.Mongo . Se a propriedade WriteConcern da Mongotemplate não estiver definida, ela será padrão para o conjunto no banco de dados do driver do MongoDB ou na configuração de coleção.

WRITECONCERNRESOLVER

Para casos mais avançados em que você deseja definir diferentes valores de WriteConcern em uma base por operação (para remover, atualizar, inserir e salvar operações), uma interface de estratégia chamada WriteConcernResolver pode ser configurada no Mongotemplate . Como o Mongotemplate é usado para persistir Pojos, o WriteConcernResolver permite criar uma política que possa mapear uma classe Pojo específica para um valor de WriteConcern. A interface WritEconcernResolver é mostrada abaixo.

público interface WRITECONCERNRESOLVER

O argumento aprovado, MongoAction, é o que você usa para determinar o valor WritEConern a ser usado ou para usar o valor do próprio modelo como padrão. MongoAction contém o nome da coleção que está sendo escrito, o Java.Lang.Classe do Pojo, o DBObject convertido, bem como a operação como uma enumeração (MongoActionOperation: Remover, Atualizar, Inserir, Inserir_list, Salvar) e algumas outras informações contextuais. Por exemplo,

Classe privada MyAppWritEConcernResolver implementa WriteConcernResolver < public WriteConcern resolve(MongoAction action) < if (action.getEntityClass().getSimpleName().contains("Audit")) < return WriteConcern.NONE; >caso contrário, se (ação.getentityclass ().getSImplename ().contém ("metadados")) < return WriteConcern.JOURNAL_SAFE; >Ação de retorno.getDefaultWritEConcern (); >>

5.5 Salvamento, atualização e remoção de documentos

O Mongotemplate fornece uma maneira simples de você salvar, atualizar e excluir seus objetos de domínio e mapear esses objetos para documentos armazenados no MongoDBB.

Dada uma classe simples como a pessoa

público aula Pessoa < privado ID da string; privado Nome da string; privado int idade; público Pessoa (nome da string, int idade) < esse.nome = nome; esse.idade = idade; > público String getId () < retornar eu ia; > público String getName () < retornar nome; > público int getage () < retornar idade; > @Sobrepor público String ToString () < retornar "Pessoa [id hl-string"> ", nome hl-string"> ", idade hl-string"> "]"; >>

Você pode salvar, atualizar e excluir o objeto como mostrado abaixo.

MongoooPerações é a interface que o Mongotemplate implementa.

pacote org.primavera.exemplo; importar estático org.Springframework.dados.MongoDB.essencial.consulta.Critério.onde; importar estático org.Springframework.dados.MongoDB.essencial.consulta.Atualizar.atualizar; importar estático org.Springframework.dados.MongoDB.essencial.consulta.Consulta.consulta; importar Java.util.Lista; importar org.apache.Comuns.exploração madeireira.Registro; importar org.apache.Comuns.exploração madeireira.LogFactory; importar org.Springframework.dados.MongoDB.essencial.Mongoooperações; importar org.Springframework.dados.MongoDB.essencial.Mongotemplate; importar org.Springframework.dados.MongoDB.essencial.SimpleMongodBFactory; importar com.MongoDB.Mongo; público aula MongoApp < privado estático final Log log = logFactory.GetLog (Mongoapp.aula); público estático vazio principal (string [] args) joga Exceção < MongoOperations mongoOps = novo Mongotemplate (novo SimpleMongodBFactory (novo Mongo (), "base de dados")); Pessoa p = novo Pessoa("Joe", 34); // insert é usado para armazenar inicialmente o objeto no banco de dados. Mongoops.inserir (p); registro.informação ("Insira:" + p); // Encontrar P = Mongoops.FindbyId (p.getid (), pessoa.aula); registro.informação ("Encontrado: " + p); // Atualizar Mongoops.UpdateFirst (Query (onde ("nome").é("Joe")), atualizar("idade", 35), Pessoa.aula); P = Mongoops.FindOne (consulta (onde ("nome").é("Joe")), Pessoa.aula); registro.informação ("Atualizada: " + p); // excluir Mongoops.remover (p); // Verifique se a exclusão funcionou Listar pessoas = Mongoops.Findall (pessoa.aula); registro.informação ("Número de pessoas =:" + pessoas.tamanho()); Mongoops.Dropcollection (pessoa.aula); >>

Isso produziria a seguinte saída de log (incluindo mensagens de depuração do próprio Mongotemplate)

Debug Apping.MongopersistentityIndexCreator: 80 - Analisando a classe de classe Org.primavera.exemplo.Pessoa para informações de índice. Trabalho de depuração.dados.MongoDB.essencial.Mongotemplate: 632 - Insira DBObject Contending Fields: [_class, idade, nome] na coleção: Pessoa Informações Org.primavera.exemplo.MongoApp: 30 - Inserir: Pessoa [id = 4ddc6e784ce5b1eba3ceaf5c, nome = Joe, idade = 34] Trabalho de depuração.dados.MongoDB.essencial.Mongotemplate: 1246 - FindOne usando consulta: < "_id" : < "$oid" : "4ddc6e784ce5b1eba3ceaf5c">> em db.Coleção: banco de dados.pessoa info org.primavera.exemplo.MongoApp: 34 - Encontrado: Pessoa [id = 4ddc6e784ce5b1eba3ceaf5c, nome = Joe, idade = 34] Trabalho de depuração.dados.MongoDB.essencial.Mongotemplate: 778 - Atualização de chamada usando consulta: < "name" : "Joe">e atualização: < "$set" : < "age" : 35>> Na coleção: trabalho de depuração de pessoas.dados.MongoDB.essencial.Mongotemplate: 1246 - FindOne usando consulta: < "name" : "Joe">em db.Coleção: banco de dados.pessoa info org.primavera.exemplo.MongoApp: 39 - Atualizado: Pessoa [id = 4ddc6e784ce5b1eba3ceaf5c, nome = Joe, idade = 35] Trabalho de depuração.dados.MongoDB.essencial.Mongotemplate: 823 - Remova usando a consulta: < "id" : "4ddc6e784ce5b1eba3ceaf5c">Na coleção: Org de informações da pessoa.primavera.exemplo.MongoApp: 46 - Número de pessoas =: 0 Trabalho de depuração.dados.MongoDB.essencial.Mongotemplate: 376 - Coleção descartada [banco de dados.pessoa]

Houve conversão implícita usando o mongoconverter entre uma string e objectId, conforme armazenado no banco de dados e reconhecendo uma convenção da propriedade “ID” Nome.

Este exemplo deve mostrar o uso de salvar, atualizar e remover operações no Mongotemplate e não mostrar funcionalidade de mapeamento complexa

A consulta Stynax usada no exemplo é explicada em mais detalhes na seção Documentos de consulta.

5.5.1 Como o campo ‘_id’ é tratado na camada de mapeamento

MongoDB exige que você tenha um campo ‘_id’ para todos os documentos. Se você não fornecer um, o driver atribuirá um objeto com um valor gerado. Ao usar o MongomappingConverter, existem certas regras que governam como as propriedades da classe Java são mapeadas para este campo ‘_id’.

Os seguintes descrevem qual propriedade será mapeada para o campo de documentos ‘_id’:

• Uma propriedade ou campo anotado com @id (org.Springframework.dados.anotação.Id) será mapeado para o campo ‘_id’.
• Uma propriedade ou campo sem anotação, mas o nome nomeado será mapeado para o campo ‘_id’.

Os seguintes descrevem que tipo de conversão, se houver, será feita na propriedade mapeada para o campo de documentos _id ao usar o MappingMongoconverter, o padrão para o Mongotemplate .

• Uma propriedade de identificação ou campo declarado como uma string na classe Java será convertido e armazenado como um objectID, se possível, usando um conversor de mola . Regras de conversão válidas são delegadas ao driver Java MongoDB. Se não puder ser convertido em um objectId, o valor será armazenado como uma string no banco de dados.
• Uma propriedade de identificação ou campo declarado como biginteger na classe Java será convertido e armazenado como um objeto usando um conversor de mola .

Se nenhum campo ou propriedade especificada acima estiver presente na classe Java, um arquivo ‘_id’ implícito será gerado pelo motorista, mas não mapeado para uma propriedade ou campo da classe Java.

Ao consultar e atualizar o Mongotemplate, usará o conversor para lidar.

5.5.2 mapeamento de tipo

Como as coleções do MongoDB podem conter documentos que representam instâncias de uma variedade de tipos. Um ótimo exemplo aqui é se você armazenar uma hierarquia de aulas ou simplesmente ter uma aula com uma propriedade de objeto de tipo . Neste último caso, os valores mantidos dentro dessa propriedade devem ser lidos corretamente ao recuperar o objeto. Assim, precisamos de um mecanismo para armazenar informações de tipo ao lado do documento real.

Para conseguir que o MappingMonGoconverter usa uma abstração mongoltiPeMPERAP. Seu comportamento padrão está armazenando o nome de classe totalmente qualificado em _class dentro do documento para o documento de nível superior, bem como para cada valor, se for um tipo complexo e um subtipo do tipo de propriedade declarado declarado.

Exemplo 5.7. Tipo de mapeamento

público aula Amostra < Contact value; >público abstrato aula Contato < … >público aula Pessoa estende -se Contato < … >Amostra de amostra = novo Amostra(); amostra.valor = novo Pessoa(); Mongotemplate.salvar (amostra); < "_aula" : "Com.acme.Amostra", "valor" : < "_aula" : "Com.acme.Pessoa" >>

Como você pode ver, armazenamos as informações de tipo para o persistimento da classe raiz real, bem como para o tipo aninhado, pois é complexo e um subtipo de contato . Então, se você está agora usando o Mongotemplate.Findall (objeto.classe, “amostra”), podemos descobrir que o documento armazenado deve ser uma instância de amostra. Também podemos descobrir que a propriedade do valor deve ser uma pessoa na verdade.

Mapeamento de tipo de personalização

Caso você queira evitar escrever todo o nome da classe Java como informação de tipo, mas gosta de usar alguma chave, você pode usar a anotação @Typealias na classe de entidade sendo persistida. Se você precisar personalizar o mapeamento ainda mais, dê uma olhada na interface TypeInformationMapper. Uma instância dessa interface pode ser configurada no DefaultMonGotyMeMapper que pode ser configurado por sua vez no MappingMongoconverter .

5.5.3 métodos para salvar e inserir documentos

Existem vários métodos convenientes no Mongotemplate para salvar e inserir seus objetos. Para ter mais controle de granulação fina sobre o processo de conversão, você pode registrar conversores de mola no MappingMongoconverter, por exemplo, conversor e conversor .

A diferença entre as operações de inserção e salvamento é que uma operação de salvamento executará uma inserção se o objeto ainda não estiver presente.

O caso simples de usar a operação de salvamento é salvar um pojo. Nesse caso, o nome da coleção será determinado pelo nome (não totalmente qualificado) da classe. Você também pode chamar a operação de salvamento com um nome de coleção específico. A coleção para armazenar o objeto pode ser substituída usando metadados de mapeamento.

Ao inserir ou salvar, se a propriedade ID não estiver definida, a suposição é que seu valor será autogenerado pelo banco de dados. Como tal, para autogeneração de um objectId, suceder o tipo de propriedade/campo de identificação em sua classe deve ser uma string, objectId ou biginteger .

Aqui está um exemplo básico de uso da operação de salvamento e recuperação de seu conteúdo.

Exemplo 5.8. Inserção e recuperação de documentos usando o Mongotemplate

importar estático org.Springframework.dados.MongoDB.essencial.consulta.Critério.onde; importar estático org.Springframework.dados.MongoDB.essencial.consulta.Critério.consulta; … Pessoa P = novo Pessoa("Prumo", 33); Mongotemplate.inserir (p); Pessoa QP = Mongotemplate.FindOne (consulta (onde ("idade").é(33)), Pessoa.aula);

As operações de inserção/salvamento disponíveis para você estão listadas abaixo.

• vazio salvar (Object ObjectToSave) Salve o objeto na coleção padrão.
• vazio salvar (Object ObjectToSave, String CollectionName) Salvar o objeto na coleção especificada.

Um conjunto semelhante de operações de inserção está listado abaixo

• vazio inserir (Object ObjectToSave) Insira o objeto na coleção padrão.
• vazio inserir (Object ObjectToSave, String CollectionName) Insira o objeto na coleção especificada.

Qual coleção meus documentos serão salvos em?

Existem duas maneiras de gerenciar o nome da coleção usado para operar nos documentos. O nome de coleção padrão usado é o nome da classe alterado para iniciar com uma carta de baixa caixa. Então, um com.teste.A classe de pessoa seria armazenada na coleção “Pessoa”. Você pode personalizar isso fornecendo um nome de coleção diferente usando a anotação @Document. Você também pode substituir o nome da coleção, fornecendo seu próprio nome de coleção como o último parâmetro para as chamadas de método Mongotemplate selecionadas.

Inserir ou salvar objetos individuais

O driver MongoDB suporta a inserção de uma coleção de documentos em uma operação. Os métodos na interface de mangoaperações que suportam essa funcionalidade estão listados abaixo

• inserir Insira um objeto. Se houver um documento existente com o mesmo ID, um erro será gerado.
• insertall Pega uma coleção de objetos como o primeiro parâmetro. Este método é mais.
• salvar Salve o objeto Ovewriting qualquer objeto que possa existir com o mesmo ID.

Inserindo vários objetos em um lote

O driver MongoDB suporta a inserção de uma coleção de documentos em uma operação. Os métodos na interface de mangoaperações que suportam essa funcionalidade estão listados abaixo

• inserir métodos que tomam uma coleção como o primeiro argumento. Isso insere uma lista de objetos em um único lote de gravação no banco de dados.

5.5.4 Atualizando documentos em uma coleção

Para atualizações, podemos optar por atualizar o primeiro documento encontrado usando o método da MongoooPeração UpdateFirst ou podemos atualizar todos os documentos que foram encontrados para corresponder à consulta usando o método updateMulti . Aqui está um exemplo de uma atualização de todas as contas de poupança, onde estamos adicionando um $ 50.00 bônus para o saldo usando o operador $ inc.

Exemplo 5.9. Atualizando documentos usando o Mongotemplate

importar estático org.Springframework.dados.MongoDB.essencial.consulta.Critério.onde; importar estático org.Springframework.dados.MongoDB.essencial.consulta.Consulta; importar estático org.Springframework.dados.MongoDB.essencial.consulta.Atualizar; . WRITORESULT WR = MONGOTEMPLATE.updatatemulti (novo Consulta (onde ("Contas.tipo de conta").é (conta.Tipo.POUPANÇA)), novo Atualizar().Inc ("Contas.$.equilíbrio", 50.00), Conta.aula);

Além da consulta discutida acima, fornecemos a definição de atualização usando um objeto de atualização. A classe de atualização possui métodos que correspondem aos modificadores de atualização disponíveis para o MongoDBB.

Como você pode ver, a maioria dos métodos retorna o objeto de atualização para fornecer um estilo fluente para a API.

Métodos para executar atualizações para documentos

• UpdateFirst Atualiza o primeiro documento que corresponde aos critérios do documento de consulta com o documento atualizado fornecido.
• UPDATEMULTI Atualiza todos os objetos que correspondem aos critérios do documento de consulta com o documento atualizado fornecido.

Introdução ao MongoDB e Java – Tutorial de operações CRUD

O registro de driver Java MongoDB agora está ativado pela popular API SLF4J, então adicionei logback no POM.XML e um logback de arquivo de configuração.xml .

Introdução

Nesta primeira postagem do blog da série Java Quick Start, mostrarei como configurar seu projeto Java com Maven e executar um comando mongodb em java. Em seguida, exploraremos as operações mais comuns – como criar, ler, atualizar e excluir – usando o driver Java MongoDB . Também mostrarei algumas das opções e recursos mais poderosos disponíveis como parte do driver Java MongoDB para cada uma dessas operações, oferecendo uma excelente base de conhecimento para construir enquanto passamos pela série.

Em futuras postagens do blog, seguiremos em frente e trabalharemos:

Transações com ácido multi-documental.

O MONGODB Java Reactive Streams Driver.

Por que MongoDB e Java?

Java é o idioma mais popular na indústria de TI na data desta postagem do blog, e os desenvolvedores votaram no MongoDB como seu banco de dados mais procurado quatro anos seguidos . Nesta série de postagens do blog, vou demonstrar o quão poderosas são essas duas grandes peças de tecnologia quando combinadas e como você pode acessar esse poder.

Pré -requisitos

Para seguir, você pode usar qualquer ambiente que desejar e o ambiente de desenvolvimento integrado de sua escolha. Vou usar o maven 3.6.2 e o Java OpenJDK 13, mas todo o código será compatível com as versões Java 8 a 13, então fique à vontade para usar o JDK de sua escolha e atualizar a versão Java de acordo com o POM.Arquivo XML estamos prestes a configurar.

Para o cluster do MongoDB, usaremos um cluster de MongoDB de Nível M0 de MongoDB Atlas . Se você ainda não tem um, confira minha postagem de blog M0 Cluster.

Obtenha seu cluster M0 gratuito no MongoDB Atlas hoje. É grátis para sempre, e você poderá usá -lo para trabalhar com os exemplos nesta série de blogs.

Vamos pular e dar uma olhada em como Java e MongoDB trabalham juntos.

Sendo configurado

Para começar, precisaremos configurar um novo projeto Maven. Você tem duas opções neste momento. Você pode clonar o repositório Git desta série ou pode criar e configurar o projeto Maven.

Usando o repositório Git

Se você optar por usar o Git, obterá todo o código imediatamente. Eu ainda recomendo que você leia a configuração manual.

Você pode clonar o repositório se quiser com o seguinte comando.

Ou você pode baixar o repositório como um arquivo zip .

Configurando manualmente

Você pode usar seu IDE favorito para criar um novo projeto Maven para você ou pode criar o projeto MAVEN manualmente. De qualquer maneira, você deve obter a seguinte arquitetura de pastas:

O pom.O arquivo XML deve conter o seguinte código:

Para verificar se tudo funciona corretamente, você poderá criar e executar um simples “Hello MongoDB!” programa. Em src/main/java/com/mongodb/quickstart, crie o hellomongodb.Arquivo Java:

Em seguida, compile e execute -o com seu IDE ou use a linha de comando no diretório raiz (onde está a pasta SRC):

O resultado deve ficar assim:

Nota: Se você vir alguns avisos sobre um acesso reflexivo ilegal de Guice.Java, é seguro ignorá -los. Guice é usado pelo Maven e precisa de uma atualização. Você pode ler mais sobre isso nesta questão do github . Esses avisos desaparecerão em uma versão futura de Guice e Maven.

Conectando -se com Java

Agora que nosso projeto MAVEN funciona e resolvemos nossas dependências, podemos começar a usar o MongoDB Atlas com Java.

Se você importou o conjunto de dados de amostra, conforme sugerido na postagem do blog do Quick Start Atlas, com o código Java que estamos prestes a criar, você poderá ver uma lista dos bancos de dados no conjunto de dados de amostra.

O primeiro passo é instanciar um mongocliente passando uma string de conexão do MongoDB Atlas para os mongoclientes.Create () Método estático. Isso estabelecerá uma conexão com o MongoDB Atlas usando a string de conexão. Em seguida, podemos recuperar a lista de bancos de dados neste cluster e imprimi -los para testar a conexão com o MongoDB.

Em src/main/java/com/mongodb, crie a conexão.Arquivo Java:

Como você pode ver, a sequência de conexão do MongoDB é recuperada do Propriedades do sistema , Então, precisamos configurar isso. Depois de recuperar sua string de conexão MongoDB Atlas, você pode adicionar o MongoDB.Propriedade do sistema URI em seu IDE. Aqui está minha configuração com o Intellij, por exemplo.

Ou se você preferir usar o Maven na linha de comando, aqui está a linha de comando equivalente que você pode executar no diretório raiz:

Nota: Não se esqueça das citações duplas em torno do Uri MongoDB para evitar surpresas do seu shell.

A saída padrão deve ser assim:

Insira operações

Sendo configurado

Na seção de conexão com Java, criamos as classes Hellomongodb e conexão . Agora vamos trabalhar na aula de criação.

Se você não configurou seu cluster gratuito no MongoDB Atlas, agora é um ótimo momento para fazê -lo. Obtenha as instruções para criar seu cluster .

Verificando o modelo de coleta e dados

No conjunto de dados de amostra, você pode encontrar o banco de dados Sample_training, que contém um grau de coleção . Cada documento nesta coleção representa as notas de um aluno para uma aula específica.

Aqui está a representação JSON de um documento no Mongo Shell .

E aqui está a representação JSON estendida do mesmo aluno. Você pode recuperá -lo no MongoDB Compass, nossa ferramenta GUI gratuita, se quiser.

JSON Extended é a versão legível humana de um documento BSON sem perda de informações do tipo. Você pode ler mais sobre o motorista Java e BSON na documentação do driver Java MongoDB .

Como você pode ver, o MongoDB armazena documentos BSON e para cada par de valores-chave, o BSON contém a chave e o valor junto com seu tipo. É assim que o MongoDB sabe que Class_ID é realmente um duplo e não um número inteiro, o que não é explícito na representação da concha mongagem deste documento.

Já temos 10.000 alunos (Student_id de 0 a 9999) nesta coleção e cada um deles teve 10 classes diferentes, o que adiciona até 100.000 documentos nesta coleção. Digamos que um novo aluno (Student_id 10.000) acabou de chegar nesta universidade e recebeu várias notas (aleatórias) em sua primeira classe. Vamos inserir este novo documento de aluno usando o Java e o MongoDB Java Driver.

Nesta universidade, o Class_ID varia de 0 a 500, para que eu possa usar qualquer valor aleatório entre 0 e 500.

Integração de Java MongoDB: 12 ​​etapas fáceis

Comece com operações do MongoDB CRUD em Python: 3 etapas fáceis AGREGAÇÃO DA SUBSTRIÇÃO DE MONGODB (SUBSTR): simplificado 101 Conector JavaScript (NodeJS) MongoDB simplificado 101

Índice

Esta página fornece uma visão geral abrangente de como você pode começar com MongoDB e Java. Neste post, você’aprenderei como conectar seu aplicativo Java a uma instância do MongoDB. Em seguida, você realizará algumas operações comuns do MongoDB usando o driver Java MongoDB. Leia para configurar seu MongoDB Java Integração hoje!

Índice

O que é MongoDB?

MongoDB é um banco de dados de documentos de código aberto que possui uma ampla gama de aplicativos. Pode ser usado como um banco de dados analítico, banco de dados transacional, índice de pesquisa ou data warehouse, entre outros casos de uso. O MongoDB possui um esquema flexível que fornece suporte para indexação completa, replicação, armazenamento do tipo JSON e uma linguagem de consulta não estruturada.

Os principais conceitos do MongoDB são:

• Eu ia: Um ID é um nome de campo usado para representar um objeto único em MongoDBB. Pode ser criado explicitamente pelo usuário ou implicitamente pelo servidor MongoDBB.
• Coleção: É um balde que armazena um grupo de documentos do MongoDB. Ele se enquadra em um banco de dados na hierarquia.
• Base de dados: Este é o nível mais alto da organização de dados em uma instância do MongoDB. As coleções de armazenamento de banco de dados e uma instância do MongoDB podem conter muitos bancos de dados.
• Documento: Os registros armazenados em uma coleção MongoDB são chamados de documentos. Eles contêm chaves e valores. Os valores podem ser strings, números inteiros, booleanos, datas, bem como outros documentos incorporados.
• Campo: refere -se ao par de chaves/valor em um documento.

Resolva seus problemas de replicação de dados com os pipelines confiáveis ​​e automatizados confiáveis ​​e automatizados com mais de 150 conectores.

Principais características do MongoDB

MongoDB tem vários recursos extraordinários que o tornam amplamente utilizável e popular. Vamos dar uma olhada nos principais recursos técnicos do MongoDB:

Suporta consultas do ADHOC

Um dos maiores benefícios que destacam o MongoDB é o desempenho ao lidar com consultas ad hoc em dados que geralmente são atualizados em tempo real. MongoDB pode executar pesquisas de campo, pesquisas de alcance e consultas de expressão regulares.

Indexação

A indexação é uma característica importante de um banco de dados para melhorar a velocidade de pesquisa e o desempenho das consultas de pesquisa. Sem indexação, um banco de dados seria forçado a digitalizar documentos um por um para selecionar aqueles que correspondem à consulta que seria ineficiente. No entanto, se cada consulta tiver um índice apropriado, as solicitações do usuário poderão ser executadas rapidamente pelo servidor. Com a indexação do MongoDB, é possível com qualquer campo ou chave, em um documento que sustente padrões de acesso complexos para conjuntos de dados.

Banco de dados sem esquema

Os bancos de dados relacionais clássicos usam um esquema para definir todos os elementos funcionais, incluindo tabelas, visualizações de linhas, índices e relacionamentos. Em MongoDB, uma coleção mantém documentos diferentes. Não possui esquema, então pode haver numerosos documentos em uma coleção, com chaves distintas, e essas chaves podem ser únicas. Um banco de dados de esquema, como o MongoDB, é mais flexível, pois não possui essas restrições iniciais, mapeando para um banco de dados mais natural.

Para saber mais sobre o MongoDB, visite aqui.

O que é Java?

Java é uma linguagem de programação popular que’é usado principalmente para desenvolvimento do lado do servidor, bem como desenvolvimento de aplicativos móveis. Em seu design, o Java é uma linguagem orientada a objetos que significa simplesmente que todos os dados e métodos são representados como classes e objetos.

Java pode ser compilado ou interpretado, o que significa que a tradução do código Java para ByteCode ou formato binário pode ser feito usando um compilador ou intérprete. Desde que’é uma linguagem compilada, é’é muito rápido em tempo de execução e também muito fácil de depurar.

Alguns principais casos de uso de Java incluem o desenvolvimento:

• Aplicações Android
• Aplicativos GUI da área de trabalho
• Aplicativos da web
• Aplicações científicas
• Aplicativos do lado do servidor do setor financeiro
• Sistemas incorporados

Principais recursos de Java

Os seguintes recursos dão à Java uma vantagem sobre outras linguagens de programação:

• Orientado a Objeto: Linguagem de programação java trata tudo como um objeto. Ele pode facilmente mapear cenários do mundo real em código, tratando entidades individuais como objetos.
• Plataforma independente: Diferentemente das linguagens de programação-como C e C ++, o Java não é compilado em uma máquina específica da plataforma. Produz um código de byte independente da plataforma que é distribuído pela Internet e é interpretado pela Java Virtual Machine (JVM) instalada em qualquer sistema.
• Segurança: Com o recurso de segurança da linguagem de programação Java, ele permite que você desenvolva sistemas à prova de violação e sem vírus. Além disso, usa técnicas de autenticação baseadas em criptografia de chave pública para manter seu código e dados seguros.
• Portátil: Java é uma linguagem de programação independente da arquitetura. Portanto, é fácil portar um código escrito na linguagem de programação Java para diferentes processadores.
• Robusto: Java é uma linguagem de programação que se esforça para eliminar instâncias propensas a erros usando a verificação de erros do tempo de compilação e a verificação do tempo de execução.

Para saber mais sobre a linguagem de programação Java, visite aqui.

Simplifique sua análise de dados com o Pipeline de dados sem código do HEVO

Dados do HEVO, um pipeline de dados automatizado sem código ajuda a carregar dados de qualquer fonte de dados, como bancos de dados, aplicativos SaaS, armazenamento em nuvem, SDK, S e serviços de streaming e simplifica o processo ETL. Ele suporta mais de 100 fontes de dados como MongoDB e carrega os dados no data warehouse desejado, enriquece os dados e o transforma em um formulário pronto para análise sem escrever uma única linha de código.

Seu pipeline completamente automatizado oferece dados a serem entregues em tempo real sem qualquer perda de fonte para destino. Sua arquitetura tolerante a falhas e escalável garante que os dados sejam tratados de maneira segura e consistente com a perda de dados zero e suporta diferentes formas de dados. As soluções fornecidas são consistentes e trabalham com diferentes ferramentas de inteligência de negócios (BI).

Confira por que o Hevo é o BESt:

• Seguro: O Hevo tem uma arquitetura tolerante a falhas que garante que os dados sejam tratados de maneira segura e consistente com a perda de dados zero.
• Gerenciamento de esquema: O Hevo tira a tediosa tarefa de gerenciamento de esquema e detecta automaticamente o esquema de dados recebidos e mapeia para o esquema de destino.
• Aprendizado mínimo: Hevo, com sua interface de interface simples e interativa, é extremamente simples para novos clientes trabalharem e executarem operações.
• Hevo é construído para escalar: À medida que o número de fontes e o volume de seus dados cresce, o Hevo escala horizontalmente, lidando com milhões de registros por minuto com muito pouca latência.
• Carga de dados incrementais: O HEVO permite a transferência de dados que foram modificados em tempo real. Isso garante a utilização eficiente da largura de banda em ambas as extremidades.
• Apoio ao vivo: A equipe do Hevo está disponível 24 horas para estender o suporte excepcional a seus clientes por meio de chamadas de bate -papo, e -mail e suporte.
• Monitoramento ao vivo: O Hevo permite que você monitore o fluxo de dados e verifique onde seus dados estão em um determinado momento.

Quais são as etapas para configurar a integração do MongoDB Java?

Felizmente, até agora, você adquiriu algum entendimento básico de MongoDB e Java, bem como por que eles’é usado no desenvolvimento de aplicativos. Agora deixe’mergulhe e dê uma olhada nas etapas usando as quais você pode configurar MongoDB Java integração:

• Etapa 1: Instale o pacote OpenJDK
• Etapa 2: defina a variável de ambiente java_home
• Etapa 3: Instale o MongoDB
• Etapa 4: instale um IDE ou editor
• Etapa 5: Configure um novo projeto Java
• Etapa 6: Instale a Biblioteca de Clientes Java MongoDB
• Etapa 7: Use a Biblioteca de Clientes Java MongoDB
• Etapa 8: Crie uma coleção MongoDB
• Etapa 9: Crie documentos
• Etapa 10: Documentos de consulta
• Etapa 11: Atualizar documentos
• Etapa 12: Excluir documentos

Etapa 1: Instale o pacote OpenJDK

Para seguir junto com a configuração do Java MongoDB, você’Primeiro precisará preparar sua máquina local para o desenvolvimento de Java. Para fazer isso, você precisa primeiro instalar o pacote OpenJDK 8 (Open Java Development Kit).

1) Linux

Se você’Re no Debian ou Ubuntu, abra sua linha de comando e execute o seguinte comando:

$ sudo apt-get install OpenJDK-8-JDK

Para o CentOS, Red Hat, Oracle, Fedora e outras distribuições semelhantes de Linux, usam o seguinte comando:

$ su -c "yum install java -1.8.0-openjdk-devel "

2) macOS

Se você’Re no macOS, use o seguinte comando:

% Brew Install OpenJdk@8

Em seguida, crie um link simbólico para que o invólucro java possa encontrá -lo:

% sudo ln -sfn/usr/local/opt/openjdk@8/libexec/openjdk.JDK/Biblioteca/Java/JavavirtualMachines/OpenJDK-8.JDK 

3) janelas

• Baixe o instalador baseado em MSI deste link.
• Extraia os arquivos ZIP para uma pasta.
• Execute o OpenJDK 8 para o Windows Installer.
• Siga os avisos na tela para instalar.

Etapa 2: defina a variável de ambiente java_home

Depois que seu JDK estiver no lugar, você precisa instalar o ambiente Java para prosseguir com sua integração de Java MongoDB.

1) Linux

1. Abra seu terminal e tipo:

sudo nano /etc /perfil

1. Em seguida, vá para o final do arquivo e digite:

exportar java_home =/usr/lib/jvm/java-8-openjdk-amd64/bin/java Caminho de exportação = $ java_home/bin: $ caminho

1. Salve o arquivo e saia (Ctrl+O, Ctrl+X).

2) macOS

1. Abra seu terminal e tipo:

Emacs .perfil

1. Em seguida, vá para o final do arquivo e digite:

Java_home =/biblioteca/java/home export java_home;

1. Salvar e sair (Ctrl-x, Ctrl-S; Ctrl-x, Ctrl-C).

3) janelas

Para definir a variável de ambiente em sua máquina Windows, abra o prompt de comando com privilégios de administrador e execute o seguinte comando:

setx -m java_home "c: programa ~ 1javajdk1.8.0_xx "

Em seguida, reinicie o prompt de comando para recarregar as variáveis ​​do ambiente. Execute o seguinte comando para verificar se o caminho foi adicionado:

eco %java_home %

Etapa 3: Instale o MongoDB

Depois de terminar a parte Java da integração do MongoDB Java, é hora de instalar o MongoDB e suas ferramentas.

1) Linux

1. Abra um terminal e emita o comando a seguir para importar a chave pública do MongoDB do sistema de gerenciamento de pacotes:

wget -qo - https: // www.MongoDB.org/static/pgp/server-5.0.ASC | Sudo Apt-Key Add -

1. Em seguida, crie um arquivo de lista emitindo o seguinte comando:

eco "Deb [arch = amd64, Arm64] https: // repo.MongoDB.org/apt/ubuntu focal/mongodb-org/5.0 Multiverse "| sudo tee/etc/apt/fontes.lista.D/MONGODB-ORG-5.0.lista

1. Atualize o banco de dados do pacote.

Atualização de sudo apt-get

1. Execute o seguinte comando para instalar o MongoDB:

sudo apt-get install -y mongodb-org

1. Comece o MongoDB:

sudo systemctl start mongod

1. Verifique se o MongoDB está em execução:

SUDO SYSTEMCTL STATUS MONGOD

MongoDB deve estar em execução na porta 27017.

As instruções acima foram testadas no Ubuntu 20.0. Você pode obter as instruções de instalação para outras distribuições Linux do link seguinte.

2) macOS

1. Emita o seguinte comando para baixar a fórmula Homebrew para MongoDB:

Brew Tap MongoDB/Brew

1. Instale o MongoDB usando o seguinte comando:

Brew Instale [email protected]

1. Para computadores macos executando os processadores Intel, inicie o MongoDB usando o seguinte comando:

MongoD -Config/usr/local/etc/mongod.Conf -Fork

1. Para computadores macos executando processadores M1, use o seguinte comando:

mongod -config/opt/homebraw/etc/mongod.Conf -Fork

3) janelas

1. Faça o download do instalador baseado em MSI do MongoDB deste link.

1. Execute o instalador clicando duas vezes .arquivo msi.

1. Siga os avisos na tela para instalar.

Etapa 4: instale um IDE ou editor

Para executar os exemplos dados neste blog, recomendamos que você use um ambiente de desenvolvimento integrado (IDE). Isso porque torna muito mais conveniente você configurar o maven ou o gradle ao criar e executar seu projeto Java.

Abaixo de você’encontrará uma lista de alguns editores populares usados ​​para desenvolver aplicativos Java e se adequarei ao seu MongoDB Java integração:

• Átomo por github
• Intellij Idea por jetbrains
• Código do Visual Studio pela Microsoft
• Eclipse by Eclipse Foundation

Esses IDEs oferecem recursos úteis, como destaque de sintaxe, conclusão de código, recursos de depuração totalmente integrados e muito mais.

Etapa 5: Configure um novo projeto Java

Usando seu IDE favorito, crie um novo projeto Maven ou Gradle. Se você’REJA MAVEN, você deve obter a seguinte estrutura de pastas:

Java-Quick-Start/.xml Src Main â Java 

Se você estiver usando o gradle, deve ter a seguinte estrutura de pastas:

construir.gradle src

Etapa 6: instale a biblioteca de clientes do MongoDB para Java

A biblioteca de clientes do MongoDB para Java permite que você se conecte e se comunique com sua instância do MongoDB de um aplicativo Java.

Se você estiver usando o Maven, adicione a biblioteca de clientes Java MongoDB à sua lista de dependências em sua pom.xml arquivo.

  org.MongoDB MongoDB-Driver-Sync 4.4.1   

Seu pom.xml O arquivo agora deve ficar assim:

  4.0.0 com.MongoDB Java-Quick-Start 1.0-SNAPSHOT 8 8 UTF-8 4.4.1 3.10.0   org.MongoDB MongoDB-Driver-Sync $    org.apache.Maven.plugins MAVEN-COMPILER-PLUGIN $ $ $     

Se você’estar usando o gradle, adicione o seguinte trecho de código ao seu construir.Gradle Lista de dependências para sua integração de Java MongoDB:

dependências

Seu construir.Gradle O arquivo deve se parecer com o seguinte arquivo:

plugins < id 'base' >importação org.Gradle.distribuição.Download de versões de gradra = '0.1 'dependências < compile 'org.mongodb:mongodb-driver-sync:4.4.1' >tarefas.Register ('Downloadgradle', Download Gradle) < description = 'Downloads the Gradle distribution with a given version.' gradleVersion = '4.6' >tarefas.Register ('CreateCustomgradledistribution', ZIP) < description = 'Builds custom Gradle distribution and bundles initialization scripts.' dependsOn downloadGradle def projectVersion = project.version archiveFileName = downloadGradle.gradleVersion.map < gradleVersion ->"Mycompany-gradle-$-$-bin.zip "> de Ziptree (Downloadgradle.DestinationFile) de ('src/init.d ') < into "$/init.d" > > 

Etapa 7: Usando a Biblioteca de Clientes Java MongoDB

Para usar a biblioteca de clientes Java MongoDB, crie um arquivo que conterá seu aplicativo dentro do diretório de pacotes base do seu projeto. Você pode nomear Aplicativo.Java.

Adicione as seguintes instruções de importação para inicializar a biblioteca:

importar estático com.MongoDB.cliente.modelo.Filtros.Eq; importação org.BSON.Documento; importar com.MongoDB.cliente.Mongocliente; importar com.MongoDB.cliente.Mongoclientes; importar com.MongoDB.cliente.Mongocollection; importar com.MongoDB.cliente.Mongodatabase;

Etapa 8: Crie uma coleção MongoDB

Com isso fora do caminho, é’agora é hora de sua integração de Java MongoDB interage com o banco de dados. Deixar’s primeiro começo criando uma coleção. Você pode criar uma coleção MongoDB especificando o banco de dados de destino usando o getDatabase () método e depois invocando o createCollection () Método do com.MongoDB.cliente.Mongodatabase interface. Este método aceita um valor literal da string com o nome da coleção. Se o banco de dados não existir, o MongoDB o criará implicitamente.

O snippet de código a seguir cria uma coleção em um banco de dados MongoDB:

importar java.util.Matrizes; importação org.BSON.Documento; importação org.BSON.tipos.ObjectId; importar com.MongoDB.Mongoexception; importar com.MongoDB.cliente.Mongocliente; importar com.MongoDB.cliente.Mongoclientes; importar com.MongoDB.cliente.Mongocollection; importar com.MongoDB.cliente.Mongodatabase; importar com.MongoDB.cliente.resultado.InsertoneResult; CreateCollection de classe pública < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; // Create a MongoDB Client MongoClient mongoClient = MongoClients.create(uri)); // Create a MongoDB database MongoDatabase database = mongoClient.getDatabase("usersDB"); // Create a MongoDB Collection MongoCollectioncollection = database.createCollection("users"); System.out.println("Collection Created Successfully!"); > >

Etapa 9: Crie documentos

O snippet seguinte usa o insertone () Método para inserir um documento no usuário’s coleção que você criou na etapa anterior. Se o banco de dados ou coleção não existir, o MongoDB criará os dois.

importar java.util.Matrizes; importação org.BSON.Documento; importação org.BSON.tipos.ObjectId; importar com.MongoDB.Mongoexception; importar com.MongoDB.cliente.Mongocliente; importar com.MongoDB.cliente.Mongoclientes; importar com.MongoDB.cliente.Mongocollection; importar com.MongoDB.cliente.Mongodatabase; importar com.MongoDB.cliente.resultado.InsertoneResult; insertona de classe pública < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); try < InsertOneResult result = collection.insertOne(new Document() .append("_id", new ObjectId()) .append("username", "vitali@30") .append("phonenumber", 2501345876) .append("email", "[email protected]) ); System.out.println("Success! Inserted document id: " + result.getInsertedId()); >Catch (MongoException Me) < System.err.println("Unable to insert due to an error: " + me); >>>> 

Também é possível inserir vários documentos em uma coleção de uma só vez, invocando o InsertMany () método. Para inserir vários documentos, você deve adicioná -los a uma lista e passar essa lista como uma matriz. O snippet de código a seguir ilustra como você pode usar o InsertMany () método para conseguir isso.

importar java.util.Matrizes; importar java.util.Lista; importação org.BSON.Documento; importar com.MongoDB.Mongoexception; importar com.MongoDB.cliente.Mongocliente; importar com.MongoDB.cliente.Mongoclientes; importar com.MongoDB.cliente.Mongocollection; importar com.MongoDB.cliente.Mongodatabase; importar com.MongoDB.cliente.resultado.InsertmanyResult; InsertMany de classe pública < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); List userList = Arrays.asList( new Document().append("username", "owen hart"), new Document().append("username", "jack grealish")); try < InsertManyResult result = collection.insertMany(userList); System.out.println("Inserted document ids: " + result.getInsertedIds()); >Catch (MongoException Me) < System.err.println("Unable to insert due to an error: " + me); >>>> 

Etapa 10: Documentos de consulta

Trabalhando com sua integração Java MongoDB, você pode recuperar documentos em uma coleção invocando o encontrar() método. Este método retorna um objeto iterável que contém todos os documentos em uma coleção:

importar com.MongoDB.cliente.Finditerable; importar com.MongoDB.cliente.Mongocollection; importar com.MongoDB.cliente.Mongodatabase; importar java.util.Iterador; importação org.BSON.Documento; importar com.MongoDB.Mongocliente; Classe pública Find < public static void main( String[] args ) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); FindIterable iterDoc = collection.find(); Iterator it = iterDoc.iterator(); while (it.hasNext()) < System.out.println(doc.it.next()); >>>> 

Etapa 11: Atualizar documentos

Atualizações em um banco de dados MongoDB podem ser feitas usando o updateOne () Método do Atualizações aula. No exemplo a seguir, você estará atualizando o valor do número de telefone e adicionará um endereço ao documento que corresponde ao nome de usuário “vitali@30”.

importação org.BSON.Documento; importação org.BSON.conversões.BSON; importar com.MongoDB.Mongoexception; importar com.MongoDB.cliente.Mongocliente; importar com.MongoDB.cliente.Mongoclientes; importar com.MongoDB.cliente.Mongocollection; importar com.MongoDB.cliente.Mongodatabase; importar com.MongoDB.cliente.modelo.UpdateOptions; importar com.MongoDB.cliente.modelo.Atualizações; importar com.MongoDB.cliente.resultado.UpdateResult; Atualização de classe pública < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); Document query = new Document().append("username", "vitali@30"); Bson updates = Updates.combine( Updates.set("phonenumber", 010154257), Updates.addToSet("address", "666, 5th Avenue, NYC")); UpdateOptions options = new UpdateOptions().upsert(true); try < UpdateResult result = collection.updateOne(query, updates, options); System.out.println("Modified document count: " + result.getModifiedCount()); System.out.println("Upserted id: " + result.getUpsertedId()); // only contains a value when an upsert is performed >Catch (MongoException Me) < System.err.println("Unable to update due to an error: " + me); >>>> 

Etapa 12: Excluir documentos

Depois que a integração do Java MongoDB é definida, você ainda pode executar uma operação de exclusão em um documento em uma mongodbcollection usando o deleteOne () método. O método aceita um filtro de consulta que corresponda ao documento que você deseja excluir.

O snippet de código a seguir excluirá um usuário usando o eq () filtrar para identificar um usuário específico com o nome de usuário “vitali@30” Da sua integração de Java MongoDB:

importar estático com.MongoDB.cliente.modelo.Filtros.Eq; importação org.BSON.Documento; importação org.BSON.conversões.BSON; importar com.MongoDB.Mongoexception; importar com.MongoDB.cliente.Mongocliente; importar com.MongoDB.cliente.Mongoclientes; importar com.MongoDB.cliente.Mongocollection; importar com.MongoDB.cliente.Mongodatabase; importar com.MongoDB.cliente.resultado.Deletesult; Classe pública DeleteOne < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); Bson query = eq("username", "vitali@30"); try < DeleteResult result = collection.deleteOne(query); System.out.println("Deleted document count: " + result.getDeletedCount()); >Catch (MongoException Me) < System.err.println("Unable to delete due to an error: " + me); >>>> 

Que’sentar! Agora você pode configurar o seu próprio MongoDB Java integração.

Conclusão

Este artigo apresentou você à linguagem de programação MongoDB e Java, juntamente com seus principais recursos. Se você concluiu com êxito este guia, deve ter uma boa idéia de como configurar o MongoDB Java integração. Você cobriu as etapas necessárias para configurar ambientes de desenvolvimento de MongoDB e Java em seu PC ou servidor. Você também abordou como usar o driver Java para se conectar à sua instância do MongoDB. Finalmente, você viu exemplos de como escrever algumas operações simples do MongoDB Java Crud.

MongoDB é uma ótima ferramenta para armazenar seus dados comerciais. No entanto, às vezes, você precisa transferir esses dados para um data warehouse para análises adicionais. Construir uma solução interna para esse processo pode ser uma tarefa cara e demorada. Os dados do HEVO, por outro lado, oferecem um pipeline de dados sem código que pode automatizar seu processo de transferência de dados, permitindo que você se concentre em outros aspectos da sua empresa, como análise, gerenciamento de clientes, etc. Esta plataforma permite que você transfira dados de mais de 100 fontes como MongoDB Para data warehouses baseados em nuvem como Snowflake, Google BigQuery, Amazon Redshift, etc. Isso lhe proporcionará uma experiência sem complicações e tornará sua vida profissional muito mais fácil.

Quero levar o Hevo para dar uma volta? Inscreva-se para uma avaliação gratuita de 14 dias e experimente a suíte hevo rica em recursos em primeira mão.

Compartilhe suas opiniões sobre MongoDB Java Integração na seção de comentários!

Java MongoDB Transações: Criação, gerenciamento e fluxos de trabalho simplificados | Um guia 101

Manusear bancos de dados e executar várias operações nos dados podem ser desafiadores. Os sistemas de gerenciamento de banco de dados foram introduzidos para resolver os problemas de gerenciamento e trabalho dos dados coletados. Um dos bancos de dados mais populares é o MongoDB. MongoDB é um dos bancos de dados mais flexíveis, e executá -lo com Java torna ainda mais rápido e fácil.

Índice

Neste artigo, você aprenderá sobre transações Java MongoDB. Além disso, discutiremos como criar, gerenciar e trabalhar com transações do MongoDB.

Índice

1. Pré -requisitos
2. O que é MongoDB?
3. Como correr MongoDB com Java?
4. O que é transação do MongoDB?
5. Criação de transações Java MongoDB
6. Gerenciamento de transações Java MongoDB
7. Fluxo de trabalho de transações Java MongoDB
8. Conclusão

Pré -requisitos

Entendimento básico dos bancos de dados.

O que é MongoDB?

MongoDB é um banco de dados NoSQL que é fundamentalmente diferente dos bancos de dados SQL. MongoDB é um banco de dados não relacional, de código aberto, independente da plataforma e baseado em documentos. Os bancos de dados SQL armazenam dados relacionados em tabelas, enquanto o MongoDB lida com dados não relacionados.

MongoDB suporta transações de ácido (atomicidade, consistência, isolamento e durabilidade) em documentos únicos ou múltiplos. Essas propriedades ácidas das transações garantem que as operações complexas de transação sejam seguras e confiáveis, garantindo validade de dados. O MongoDB introduziu vários documentos, coleções e bancos de dados de transações de ácido em MongoDB 4.0 versão.

O MongoDB é executado em sistemas operacionais padrão, Windows, Linux, MacOS e a nuvem. A edição MongoDB que é executada no sistema operacional é o servidor comunitário MongoDB, e a instalação do MongoDB na nuvem é chamada de MongoDB Atlas.

Como correr MongoDB com Java?

Instale o Java em seu sistema e seu ambiente de desenvolvimento integrado preferido (IDE) pronto. Para configurar Java e MongoDB, primeiro, você deve obter o driver Java MongoDB. Os recursos para a instalação do MongoDB serão escolhidos por dois IDEs no Gradle ou Maven. Os motoristas Java MongoDB fornecem interação síncrona e assíncrona.

Passos para obter o motorista Java MongoDB

1. Instale a versão adequada do driver MongoDB deste site. Em seguida, vá para os produtos do ícone do menu. Encontre o ‘Dados diretos’ opção e clique nele.

1. Você será redirecionado para outra página da web, onde pode encontrar o ‘Conectividade de dados’ opção no painel de visão geral, sob o qual você verá o JDBC. Clique nisso.

1. Outra página será aberta. Procure MongoDB na lista e clique nela para avançar mais.

1. Uma nova página aparecerá, onde você verá a opção de download. Clique nele e você terá duas opções; Windows e Linux. De acordo com o seu sistema operacional, clique nele para baixar.

1. Você tem que preencher um formulário para download e clicar em Download.
2. Após o download, extraia seu arquivo baixado.
3. Abra o arquivo extraído para iniciar a instalação. Clique em ‘Próximo’ para prosseguir.
4. Aceite todos os termos e condições e depois avançando clicando em seguida.
5. Nota: Não altere nada nas próximas duas janelas. Clique em Avançar para prosseguir.

1. Finalmente, você alcançará a opção de instalação. Clique nele e a instalação começará.
2. Aguarde o processo de instalação concluído.

1. Quando a instalação estiver concluída, clique em Concluído para terminar a instalação.
2. Abra sua unidade C e siga o caminho abaixo. Se você encontrar uma pasta JDBC, a instalação será bem -sucedida.

Escala sua integração de dados sem esforço com o Hevo’s tolerante a falhas sem pipeline de dados de código

Como a capacidade das empresas de coletar dados explodem, as equipes de dados têm um papel crucial na alimentação de decisões orientadas a dados. No entanto, eles lutam para consolidar os dados dispersos em seu armazém para construir uma única fonte de verdade. Pipelines quebrados, problemas de qualidade de dados, bugs e erros e falta de controle e visibilidade sobre o fluxo de dados tornam a integração de dados um pesadelo.

Mais de 1000 equipes de dados dependem do Hevo’S Plataforma de Dados Pipeline para integrar dados de mais de 150 fontes em questão de minutos. Bilhões de eventos de dados de fontes tão variados quanto aplicativos SaaS, bancos de dados, armazenamento de arquivos e fontes de streaming podem ser replicados em tempo real com Hevo’s Arquitetura tolerante a falhas. O que’S MAIS-O HEVO coloca o controle completo nas mãos de equipes de dados com painéis intuitivos para monitoramento de pipeline, gerenciamento de schema e cronogramas de ingestão/carregamento personalizados.

Isso, combinado com preços transparentes e suporte 24 × 7, nos torna o software de pipeline de dados mais especial em sites de revisão.

Faça nosso teste gratuito de 14 dias para experimentar uma maneira melhor de gerenciar pipelines de dados.

O que é transação do MongoDB?

A transação em MongoDB é um grupo lógico de processos que executa uma ou mais operações em vários documentos. A transação fornece uma maneira de agrupar e isolar várias declarações e processá -las como uma única operação.

Em vez de executar um monte de comandos individualmente, você pode usar transações para agrupar e executar os comandos em um contexto diferente.

Essas operações nas transações são as operações de leitura e gravação múltiplas realizadas de e para o banco de dados MongoDB. As transações mantêm a integridade do conjunto de operações e fornecem forte consistência de dados ao usuário final.

As transações em MongoDB têm propriedades ácidas. Essas propriedades garantem que as operações complexas sejam seguras e confiáveis. O MongoDB suporta multi-documentos e multi-documentos distribuídos.

Criação de transações Java MongoDB

As transações só podem ser realizadas em bancos de dados que são executados como parte de um grande cluster. Este cluster pode ser um cluster de banco de dados sharded ou um conjunto de réplicas. Geralmente, as transações do MongoDB são escritas e executadas a partir de aplicativos externos via métodos de API. Aqui nós’criará uma transação usando o shell do mongodb.

Observação: Após o método inicial do startTransaction (), a operação abortará automaticamente se a sessão de transação for executada por mais de 60 segundos.

A seguir estão as etapas para conceituar uma sessão de transação do começo ao fim.

dB.autores.encontrar() [ < _id: ObjectId("620397dd4b871fc65c193106"), first_name: 'James', last_name: 'Joyce', title: 'Ulysses' >, < _id: ObjectId("620398016ed0bb9e23785973"), first_name: 'William', last_name: 'Gibson', title: 'Neuromancer' >, < _id: ObjectId("6203981d6ed0bb9e23785974"), first_name: 'George', last_name: 'Orwell', title: 'Homage to Catalonia' >, < _id: ObjectId("620398516ed0bb9e23785975"), first_name: 'James', last_name: 'Baldwin', title: 'The Fire Next Time' >] 

Mesmo com uma API, você cria uma sessão de transação usando o código:

var session = db.getmongo ().Startession ()

O próximo passo é iniciar a transação chamando o método startTransaction (). Use o comando abaixo:

sessão.StartTransaction ( < "readConcern": < "level": "snapshot" >, "WRITECONCERN": < "w": "majority >>) 

Existem duas opções para o método startTransaction (): Leia a preocupação e escreva preocupação.

O conjunto de preocupações de leitura é ignorado dentro da transação no nível de coleção e banco de dados. Portanto, você deve definir a preocupação com a leitura no nível da transação no StartTransaction (). No entanto, a LEAD INTELCO PADRÃO Conjuntos para a preocupação de leitura no nível da sessão para uma transação.

Se a preocupação de leitura no nível da transação e no nível da sessão não for definida, as preocupações de leitura do nível do cliente serão definidas automaticamente. A preocupação de leitura no nível do cliente é ‘local’ Para leituras contra o primário.

A preocupação com gravação é usada para cometer as operações de gravação. As operações de gravação dentro das transações devem ser emitidas implicitamente especificando a preocupação de gravação. As operações de gravação são então comprometidas usando a preocupação com a escrita no nível da transação.

Você pode definir a preocupação de gravação no nível da transação no StartTransaction (). Se a preocupação de gravação no nível da transação não for definida, ela padrão é a preocupação com a sessão de gravação para o commit. Se as preocupações de gravação no nível da transação e no nível da sessão não forem definidas, a preocupação de gravação no nível da transação vai automaticamente para a preocupação com escrita no nível do cliente.

Gerenciamento de transações Java MongoDB

Gerenciando todas as transações pode ser um trabalho pesado, mas aqui estão algumas maneiras de gerenciar as transações. Você pode adicionar suporte à transação usando dados Java Spring e Java Mongo Drivers. Uma API do motorista faz isso:

Tente (sessão de confessão do cliente = cliente.startSession ()) < session.startTransaction(); try < collection.insertOne(session, documentOne); collection.insertOne(session, documentTwo); session.commitTransaction(); >Catch (Exceção e) < session.abortTransaction(); >> 

As sessões do cliente obtidas do cliente.StartSession () deve ter vida curta e liberada de uma só vez, quando não é mais necessário. Assim, certifique -se de incluir o comando close ().

O trecho acima contém a sessão (LSID) em cada linha de comando. ‘StartTransaction’ é enviado com o primeiro comando representando a transação. E quando concluído, a transação é cometida enviando ‘CommitTranscation.’

As versões anteriores do MongoDB não suportaram transações, então a parte essencial é configurar o MongoTransactionManager em seu ApplicationContext. Transaction Manager é um ponto de entrada para suporte à transação baseado em anotação. Para configuração, use o código abaixo:

@Configuration Class Config estende o abstratoMonGoconfiguration < @Bean MongoTransactionManager transactionManager(MongoDbFactory dbFactory) < return new MongoTransactionManager(dbFactory); >> @Service Class DocumentService < private final MongoOperations operations; DocumentService(MongoOperations operations) < this.operations = operations; >@Transaction Void InsertDocuments () < operations.insert(documentOne); operations.insert(documentTwo); >> 

Que’sentar. Não há muito para gerenciar transações Java MongoDB, então existem algumas etapas simples para serem analisadas.

Fluxo de trabalho de transações Java MongoDB

Na primeira etapa do uso da transação, você precisa iniciar uma sessão do MongoDB através de um driver. Este artigo segue uma sessão do MongoDB com o driver Java MongoDB. Em seguida, use essa sessão para executar seu grupo de operações de banco de dados. Você pode executar operações CRUD (Criar, Leia, Atualizar e Excluir) em vários documentos, coleções e fragmentos.

MongoDB’S transações têm origens de nó de gravação única, mesmo no contexto de um único fragmento. Seu mecanismo de armazenamento e protocolo de replicação são substituídos pelo caminho para transações. Abaixo está uma figura que representa um aplicativo de comércio eletrônico com 2 clientes MongoDBB.

Aqui, o Cliente 1 executa transações e o Cliente 2 lê um registro atualizado pela transação invocada pelo Cliente 1. O cliente 1 insere um novo pedido na coleção de pedidos e atualiza o estoque do item ordenado (assumindo que o pedido seja enviado com sucesso). Agora, a única preocupação de gravação adequada para a alta durabilidade dos dados é a maioria. A maioria significa a maioria das réplicas, eu.e., A maioria das réplicas é cometer as mudanças antes que as primárias reconheçam o sucesso da gravação para o cliente.

A transação será bloqueada até que pelo menos um ou dois secundários puxem a atualização do primário usando a replicação. Este processo faz MongoDB’s transação de um pouco mais lenta do que outros NOSQLs transacionais.

Conclusão

Andamos usando o MongoDB em Java e a transação’S criação, gerenciamento e fluxo de trabalho. O uso de transações Java MongoDB em bancos de dados garante que um banco de dados tenha um estado consistente depois de administrar um grupo de operações.

O MongoDB adotou o trabalho de transações da maioria dos padrões transacionais familiares implementados em MySQL, Oracle e outros bancos de dados relacionais de ácido. Ironicamente, a característica da modelagem de dados do MongoDB para dados relacionados a serem armazenados juntos em um único documento aproveita o modelo de documento que não exige transações de vários documentos. Mas os desenvolvedores admiram a flexibilidade em modelar seus dados. Assim, existe a função das transações em MongoDB.

O HEVO Data, um pipeline de dados sem código, pode transferir dados de um vasto mar de mais de 100 fontes, como o MongoDB & Atlas MongoDB para um data warehouse ou um destino de sua escolha a ser visualizado em uma ferramenta de BI. É um serviço confiável, completamente automatizado e seguro que não’T exigir que você escreva qualquer código!

Se você está usando MongoDB como seu sistema de gerenciamento de banco de dados NoSQL E procurando uma alternativa sem gravação à integração manual de dados, então o Hevo pode automatizar sem esforço para você. Hevo, com sua forte integração com mais de 100 fontes e ferramentas de BI (Incluindo mais de 40 fontes livres), permite que você não apenas exporte e carregue dados, mas também transforme e enriqueça seus dados e faça-os prontos para análise em um instante.

Quero levar o Hevo para um passeio? Inscreva -se para um Julgamento gratuito de 14 dias e simplificar seu processo de integração de dados. Confira os detalhes de preços para entender qual plano atende a todas as suas necessidades de negócios.

Conte -nos sobre sua experiência de aprender sobre o Java MongoDB Transação! Compartilhe seus pensamentos conosco na seção de comentários abaixo.