Introdução ao MongoDB da Spring Session

Verifique os pré-requisitos.

Antes de iniciar este tutorial, certifique-se de instalar e configurar os seguintes pré-requisitos:

• JDK versão 17 ou posterior

• Maven

• MongoDB Atlas cluster

• Ambiente de desenvolvimento integrado (IDE), como IntelliJ IDEA ou Eclipse

Crie um novo projeto Spring Boot .

Conclua o tutorial de integração do Spring Data framework para criar um novo aplicativo Spring Boot. Você também pode visualizar e clonar o código do aplicativo acessando o repositório SpringDataMongoBulkInsert no GitHub.

Depois de concluir este tutorial de pré-requisito, você tem um novo aplicativo que usa o Spring Data MongoDB para executar uma operação de inserção em massa em uma coleção do MongoDB.

Atualize as dependências do seu projeto .

No seu arquivo pom.xml, substitua sua dependência spring-boot-starter-parent pelo seguinte código:

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>4.0.0</version>
   <relativePath/> <!-- Lookup parent from repository -->
</parent>

Isso garante que seu aplicativo use o Spring Boot 4.0, que é compatível com o Spring Session 4.0.

Em seguida, adicione a seguinte dependência à lista de dependências do seu arquivo para usar o Spring Session MongoDB:

<dependency>
   <groupId>org.mongodb</groupId>
   <artifactId>mongodb-spring-session</artifactId>
   <version>4.0.0-rc0</version>
</dependency>

Depois de configurar suas dependências, certifique-se de que elas estejam disponíveis para seu projeto executando o gerenciador de dependências e atualizando o projeto em seu IDE.

Encontre sua string de conexão do MongoDB Atlas.

Para recuperar a string de conexão para a implantação do MongoDB , faça login na sua conta do Atlas e navegue até a página Clusters na seção Database. Clique no botão Connect para sua nova implantação.

Se você ainda não tiver um usuário de banco de dados configurado, o MongoDB solicitará que você crie e configure um novo usuário.

Clique no botão Drivers em Connect to your application e selecione "Java" no menu de seleção Driver e a versão que melhor corresponde à versão instalada no menu de seleção Version.

Certifique-se de que a opção View full code sample esteja desmarcada para visualizar somente a string de conexão.

Copie a string de conexão

Clique no botão à direita da string de conexão para copiá-la para a área de transferência, como mostrado na seguinte captura de tela:

Atualize o espaço reservado para senha.

Cole esta string de conexão em um arquivo no editor de texto de sua preferência e substitua o espaço reservado <db_password> pela senha do usuário de banco de dados. A string de conexão já está preenchida com o nome de usuário do seu usuário de banco de dados.

Salve este arquivo em uma localização segura para uso em uma etapa seguinte.

Verifique sua conexão com o MongoDB .

Navegue até seu arquivo application.properties no diretório src/main/resources. Certifique-se de que esse arquivo especifique seu banco de dados MongoDB, URI de conexão e o número de documentos a inserir, conforme descrito na seção Configure your MongoClient do tutorial Spring Data. Se configurado corretamente, seu arquivo contém o seguinte código:

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

Substitua <connection URI> o espaço reservado pelo URI de conexão que você salvou na seção anterior.

Crie sua classe de configuração da Spring Session.

Crie um novo arquivo denominado SessionConfig.java no diretório do pacote base do seu projeto e cole o seguinte código:

package com.mongodb.examples.springdatabulkinsert;
import org.mongodb.spring.session.config.annotation.web.http.EnableMongoHttpSession;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableMongoHttpSession
public class SessionConfig {
}

Essa classe de configuração habilita o gerenciamento de sessões HTTP apoiadas MongoDB para seu aplicação Spring Boot.

Crie um controlador web.

Crie um arquivo chamado ProductWebController.java no diretório do pacote base do seu projeto e cole o seguinte código:

package com.mongodb.examples.springdatabulkinsert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import jakarta.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@RestController
public class ProductWebController {
    @Autowired
    private MongoTemplate mongoTemplate;
    @GetMapping("/products/search")
    public Map<String, Object> searchProducts(
            @RequestParam(required = false) String name,
            HttpSession session) {
        
        @SuppressWarnings("unchecked")
        List<String> searchHistory = (List<String>) session.getAttribute("searchHistory");
        if (searchHistory == null) {
            searchHistory = new ArrayList<>();
        }
        
        // Defines the default search if no name is provided
        if (name == null || name.trim().isEmpty()) {
            name = "product";
        }
        
        // Adds the current search to history
        searchHistory.add(name);
        session.setAttribute("searchHistory", searchHistory);
        
        // Queries the "name" field in the "products" collection
        Query query = new Query(Criteria.where("name").regex(name, "i"));
        
        List<Product> products = mongoTemplate.find(query, Product.class, "products");
        
        return Map.of(
            "products", products,
            "sessionId", session.getId()
        );
    }
    
    @GetMapping("/products/history")
    public Map<String, Object> getSearchHistory(HttpSession session) {
        // Retrieves the search history from the session
        @SuppressWarnings("unchecked")
        List<String> searchHistory = (List<String>) session.getAttribute("searchHistory");
        if (searchHistory == null) {
            searchHistory = new ArrayList<>();
        }
        
        return Map.of(
            "searchHistory", searchHistory,
            "sessionId", session.getId(),
            "searchCount", searchHistory.size()
        );
    }
    
}

ProductWebController.java é um controlador REST que demonstra a funcionalidade da sessão interagindo com os dados do produto existente. Este arquivo define os seguintes pontos de extremidade da web:

• /products/search: Pesquisa produtos na coleção bulk.products e armazena cada termo de pesquisa na sessão do usuário

• /products/history: recupera dados do histórico de pesquisa da sessão do usuário armazenada no MongoDB

Atualize sua classe de aplicativo principal.

Antes de testar os novos pontos de extremidade da web, atualize a classe principal do aplicativo para manter o aplicativo em execução e gerar informações sobre os pontos de extremidade. Substitua o conteúdo de SpringDataBulkInsertApplication.java pelo seguinte código:

package com.mongodb.examples.springdatabulkinsert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@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("Bulk insert completed. Web endpoints are now available.");
        LOG.info("You can visit these URLs:");
        LOG.info("  http://localhost:8080/products/search?name=goose");
        LOG.info("  http://localhost:8080/products/history");
    }
}

Execute e teste seu aplicativo atualizado.

Execute seu aplicativo em seu IDE ou execute o seguinte comando em seu terminal:

./mvnw spring-boot:run

Seu aplicativo inicia, executa a operação de inserção em massa e, em seguida, fornece pontos de extremidade da web em http://localhost:8080.

Teste a funcionalidade da sessão.

Abra seu navegador da Web ou use uma ferramenta como o curl para testar os seguintes pontos de extremidade habilitados para sessão:

1. Pesquisar produtos: para consultar os documentos inseridos na bulk.products coleção, visite http://localhost:8080/products/search?name= e anexe um nome de produto ao URL. Por exemplo, você pode pesquisar documentos que tenham um name valor de ,"goose" visite http://localhost:8080/products/search?name=goose.

   O resultado contém o ID da sua sessão e uma lista de documentos que correspondem à sua query de campo name, conforme mostrado no exemplo de resultado a seguir:

   {
       "sessionId": "...",
       "products": [
           {
               "name": "goose",
               "qty": 788,
               "price": 9680,
               "available": "...",
               "unavailable": "...",
               "skuId": "276-68-7836"
           },
           {
               "name": "goose",
               "qty": 984,
               "price": 2307,
               "available": "...",
               "unavailable": "...",
               "skuId": "068-88-9345"
           },
           ...
       ]
   }

2. Visualizar histórico de pesquisa: para visualizar seu histórico de pesquisa, visite http://localhost:8080/products/history.

   O resultado contém seu ID de sessão, uma lista de nomes de produtos que você pesquisou e o número total de pesquisas, conforme mostrado na seguinte saída de exemplo:

   {
      "sessionId": "...",
      "searchHistory": [
          "goose",
          "bear"
      ],
      "searchCount": 2
   }

Reinicie seu aplicativo.

Se você interromper seu aplicativo e executá-lo novamente, o MongoDB persistirá os dados da sessão.

Interrompa seu aplicativo no IDE ou no terminal. Em seguida, reinicie-o

em seu IDE ou execute o seguinte comando em seu terminal:

./mvnw spring-boot:run

Se você visitar o http://localhost:8080/products/history URL, poderá ver seu histórico de pesquisa anterior, apesar da reinicialização do aplicação . Esses dados ainda estão disponíveis porque foram armazenados no MongoDB e não na memória.