Tutorial: Integração do framework de dados do Spring

Spring Data MongoDB

O Spring Data MongoDB é o mapeador de documento de objeto (ODM) oficial da Spring Data para o MongoDB. Ele permite que você interaja com o MongoDB usando objetos Java antigos simples(POJOs) e abstração de repositório. Ele oferece suporte a recursos específicos do MongoDB, como queries dinâmicas, indexação e mapeamento de documento aninhados, ao mesmo tempo em que reduz o código boilerplate, como chamadas manuais de find() e update().

Bota de primavera

O Spring Boot é um framework construído sobre o Spring Framework. Ele adiciona recursos de configuração automática, padrões e prontos para produção para simplificar a criação de aplicativos Java baseados em Spring, incluindo a integração com o Spring Data MongoDB. Para obter mais informações, consulte a documentação do Spring Boot .

Injeção de dependência

A injeção de dependência (DI) é um princípio fundamental do Spring Framework. Ele permite que o contêiner Spring crie e gerencie objetos, chamados feições, e então os injete em outros feições que os utilizam. Isso é diferente do desenvolvimento típico orientado a objetos, em que as classes são responsáveis por inicializar e construir os objetos que usam.

Para obter mais informações sobre injeção de dependência, consulte a página Injeção de dependência da documentação do Spring Framework.

Interface de BulkOperations de dados da primavera

BulkOperations é uma interface Spring Data MongoDB que contém uma lista de operações de gravação que podem ser aplicadas ao seu banco de dados . Ele pode lidar com qualquer combinação das seguintes operações, que são mapeadas para operações semelhantes do driver Java do MongoDB :

• insert

• updateOne

• updateMany

• replaceOne

• deleteOne

• deleteMany

• upsert

Um BulkOperation pode ser ordenado ou não ordenado. As operações em massa ordenadas executam operações sequencialmente e, se um erro for detectado, retorne com um código de erro. Operações não ordenadas são executadas em paralelo, o que significa que elas normalmente são mais rápidas. No entanto, você deve verificar manualmente se houve erros durante as operações.

Para obter mais informações sobre operações em massa, consulte os seguintes recursos:

• BulkOperations na documentação da API do Spring Framework

• Operações de gravação em massa neste guia

• Operações de gravação em massa no manual do MongoDB Server

Pré-requisitos

Certifique-se de ter os seguintes componentes instalados e configurados antes de iniciar este tutorial:

• Java 8 ou posterior

• Maven

• Um cluster MongoDB Atlas

• Um novo aplicação Spring Boot

Adicionar dependências

Certifique-se de usar uma versão do Spring Data MongoDB compatível com o driver Java do MongoDB e as versões Java que você está usando. Para obter especificações de compatibilidade, consulte a página Requisitos da documentação do Spring Data MongoDB e a página Compatibilidade deste guia.

Adicione as seguintes dependências ao seu arquivo pom.xml:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-mongodb</artifactId>
   <version>3.2.5 </version>
</dependency>
<dependency>
   <groupId>net.datafaker</groupId>
   <artifactId>datafaker</artifactId>
   <version>2.4.3</version>
</dependency>

A dependência datafaker é usada para gerar uma grande quantidade de objetos Product para usar na operação de gravação em massa.

Configure seu MongoClient

A MongoConfig classe contém a configuração do MongoClient objeto que permitirá que a estrutura de dados da Spring interaja com o MongoDB Server e defina outras opções de configuração. Para obter mais informações sobre as opções de configuração, consulte a página Especificar opções de conexão deste guia.

Este aplicação usa anotações @Configuration para classes, anotações @Bean para métodos e anotações @Value para conversão de parâmetros. Essas anotações permitem que o contêiner Spring Inversion of Control (IoC) gerencie objetos. Para obter uma explicação detalhada dessas anotações, consulte as seguintes seções do guia da estrutura de dados da Spring:

• @Configuration e @Bean anotações: configuração de contêiner baseada em Java

• @Value anotações: uso de @Value

Crie um arquivo MongoConfig.java e adicione as seguintes classes de configuração e modelo para configurar sua conexão MongoDB :

package com.mongodb.examples.springdatabulkinsert;
import com.mongodb.ConnectionString;
import com.mongodb.MongoClientSettings;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoTemplate;
@Configuration
public class MongoConfig {
    @Value("${mongodb.uri}")
    private String uri;
    @Value("${mongodb.database}")
    private String databaseName;
    @Bean
    public MongoClient mongoClient() {
        ConnectionString connectionString = new ConnectionString(uri);
        MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
            .applyConnectionString(connectionString)
            .build();
        return MongoClients.create(mongoClientSettings);
    }
    @Bean
    public MongoTemplate mongoTemplate() throws Exception {
        return new MongoTemplate(mongoClient(), databaseName);
    }
}

Defina os valores de sua string de conexão (mongodb.uri), nome do banco de dados (mongodb.database) e contagem de operações em massa (documentCount) no seu arquivo application.properties:

mongodb.database=bulk
mongodb.uri=<connection string>
documentCount=25000

Este tutorial usa um banco de dados chamado bulk e 25 cria,000 documentos para salvar. Substitua <connection string> o espaço reservado do pela string de conexão para sua implantação do Atlas . Para obter mais informações, consulte a seção Criar uma connection string deste guia.

Mapear seu objeto para um documento

O mapeamento de uma classe para uma coleção permite que o contêiner Spring IoC armazene objetos como documentos MongoDB . Você pode usar a @Document anotação para especificar para qual collection uma classe mapeia. Para obter mais informações sobre o mapeamento de objetos para documentos do MongoDB , consulte a seção Visão geral da anotação de mapeamento da documentação do Spring Data MongoDB .

A @Id anotação no código a seguir indica que o campo de objeto id mapeia para o _id campo de documento , que é usado como identificador exclusivo em documentos do MongoDB . Você pode escolher qualquer campo de qualquer tipo, exceto arrays, para ser o identificador exclusivo. Para obter mais informações, consulte a seção Como o campo _id é tratado na seção de camada de mapeamento da documentação do Spring Data MongoDB .

Use o código a seguir para criar um arquivo Product.java para definir sua classe Product e mapeá-la para sua coleção products:

@Document("products")
public class Product {
    private static final Logger LOG = LoggerFactory.getLogger(Product.class);
    @Id
    private String id;
    private String name;
    private int qty;
    private double price;
    private Date available;
    private Date  unavailable;
    private String skuId;
    public Product(String name, int qty, double price, Date available, Date unavailable, String skuId) {
        this.name = name;
        this.qty = qty;
        this.price = price;
        this.available = available;
        this.unavailable = unavailable;
        this.skuId = skuId;
    }
    public static List<Product> randomProducts(int  count) {
        Faker faker = new Faker();
        Random rand = new Random();
        List<Product> retProds = new ArrayList<>(count);
        for (int i = 0; i < count; ++i) {
            Product product = new Product(faker.animal().name(),
                    1 + rand.nextInt(998),
                    10.0 + rand.nextInt(9999),
                    new Date(), new Date(),
                    faker.idNumber().valid());
            retProds.add(product);
        }
        return retProds;
    }
    // Getters and setters
}

A classe Product inclui um método estático que gera uma array de objetos Product. Você também pode definir getters e setters para os campos.

Defina um repositório para armazenar seus produtos

O ProductRepository objeto gerenciará uma coleção de Product objetos. Seu ProductRepository objeto deve ser injetado com o MongoTemplate bean gerado na MongoConfig classe . Ao usar a @Autowired anotação com um construtor que inclui mongoTemplate como argumento, o contêiner Spring usa a injeção de construtor para injetar uma mongoTemplate dependência . Para obter mais informações sobre injeção de construtor, consulte a seção Injeção de dependência baseada em construtor da documentação do Spring Framework.

Use o código a seguir para criar o arquivo ProductRepository.java e definir sua classe ProductRepository para gerenciar uma coleção de objetos Product:

@Repository
public class ProductRepository {
    private static final Logger LOG = LoggerFactory
            .getLogger(ProductRepository.class);
    private final MongoTemplate mongoTemplate;
    @Autowired
    public ProductRepository(MongoTemplate mongoTemplate){
        this.mongoTemplate = mongoTemplate;
    }
    public void updateProductQuantity(String name, int newQuantity) {
        Query query = new Query(Criteria.where("name").is(name));
        Update update = new Update();
        update.set("quantity", newQuantity);
        UpdateResult result = mongoTemplate.updateFirst(query, update, Product.class);
        if (result == null)
            LOG.error("No documents updated");
        else
            LOG.info(result.getModifiedCount() + " document(s) updated..");
    }
    public int bulkInsertProducts(int count) {
        LOG.info("Dropping collection...");
        mongoTemplate.dropCollection(Product.class);
        LOG.info("Dropped!");
        Instant start = Instant.now();
        mongoTemplate.setWriteConcern(WriteConcern.W1.withJournal(true));
        List<Product> productList = Product.randomProducts(count);
        BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Product.class);
        bulkInsertion.insert(productList);
        BulkWriteResult bulkWriteResult = bulkInsertion.execute();
        LOG.info("Bulk insert of " + bulkWriteResult.getInsertedCount() + " documents completed in " + Duration.between(start, Instant.now()).toMillis() + " milliseconds");
        return bulkWriteResult.getInsertedCount();
    }
}

O método bulkInsertProducts() utiliza inserções em massa não ordenadas, que podem melhorar o desempenho não garantindo a ordem das operações.

Realizar uma operação em massa

A classe do aplicação principal aciona o ProductRepository para gerar o número especificado de objetos Product e salvá-los em seu banco de dados MongoDB . Ele utiliza a anotação @Autowired para injetar um ProductRepository e implementa o registro.

Adicione o seguinte código à sua classe principal para executar seu aplicação:

@SpringBootApplication
public class SpringDataBulkInsertApplication implements CommandLineRunner {
    @Value("${documentCount}")
    private int count;
    private static final Logger LOG = LoggerFactory
            .getLogger(SpringDataBulkInsertApplication.class);
    @Autowired
    private ProductRepository repository;
    public static void main(String[] args) {
        SpringApplication.run(SpringDataBulkInsertApplication.class, args);
    }
    @Override
    public void run(String... args) throws Exception {
        repository.bulkInsertProducts(count);
        LOG.info("End run");
        System.exit(0);
    }
}