Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Saiba por que o MongoDB foi selecionado como um líder no 2024 Gartner_Magic Quadrupnt()
Desenvolvedor do MongoDB
Centro de desenvolvedores do MongoDB
chevron-right
Produtos
chevron-right
MongoDB
chevron-right

Explorando os recursos avançados do Atlas Search com o MongoDB Atlas Atlas Search

Aasawari Sahasrabuddhe6 min read • Published Aug 20, 2024 • Updated Aug 20, 2024
SpringMongoDBJava
APLICATIVO COMPLETO
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Se você está acompanhando as duas primeiras partes da nossa série Atlas Search com Spring Boot, já deve entender os conceitos do Atlas Search e como criar queries usando-os. Neste artigo, abordaremos alguns tópicos e recursos mais avançados do Atlas Search, aprimorando sua capacidade de consultar dados de forma eficaz.
Para aqueles que ainda precisam explorar as partes anteriores da série, recomendamos fortemente que o façam para construir um entendimento fundamental. Você pode acessar os artigos anteriores aqui: Introdução ao MongoDB Atlas Atlas Search e Java e Explorando os recursos do Atlas Search com o Atlas Search.
Neste artigo, exploraremos tópicos avançados, como a criação de analisadores personalizados, a utilização de analisadores específicos de idiomas, o trabalho com dados GeoJSON e a realização de pesquisas em combinação com outros estágios de agregação, como $lookup.
Vamos lá!

Pré-requisitos

  1. Cadastre-se para uma conta Atlas de camada gratuita do MongoDB. Você pode começar seguindo Registrar-se na Camada Grátis para construir seu cluster do Atlas.
  2. Utilize Importar e Exportar Dados para adicionar os dados ao Atlas cluster. Os dados de exemplo estão disponíveis no repositório do Github em produtoDetalhes.json e produtoReviews.json.
  3. Instale o Java versão 17 ou superior.

Explorando os recursos avançados do Atlas Search

Caso 1: Pesquisa com analisadores de idioma

No tutorial anterior, aprenderam o uso de analisadores de idioma inglês. No entanto, o Atlas Search oferece uma ampla variedade de analisadores de idiomas além do inglês. Para obter detalhes abrangentes, consulte a documentação oficial do Language Analyzers.
Após carregar os dados em seu agrupamento do Atlas a partir de produtoDetalhes.json, você precisará criar um índice de Pesquisa do Atlas. Você pode fazer isso usando qualquer um dos métodos descritos na parte 1 de nossa série, Introdução ao MongoDB Atlas , Atlas Search e Java.
Para criar seu índice do Atlas Search, você pode usar o JSON abaixo e criar um índice usando o editor JSON na UI do Atlas .
1{
2 "analyzer": "lucene.spanish",
3 "searchAnalyzer": "lucene.spanish",
4 "mappings": {
5 "dynamic": true,
6 "fields": {
7 "productNameSpanish": {
8 "analyzer": "lucene.spanish",
9 "searchAnalyzer": "lucene.spanish",
10 "type": "string"
11 }
12 }
13 }
14}
Depois de criar o índice, você pode usar o código Java abaixo:
1public List<Document> searchWithSpanish(String query, String sampleProducts) {
2 MongoCollection<Document> collection;
3 MongoDatabase database = mongoTemplate.getDb();
4 collection = database.getCollection(sampleProducts);
5 List<Document> pipeline = Arrays.asList(new Document("$search",
6 new Document("index", "index01")
7 .append("text",
8 new Document("query", query)
9 .append("path", "productNameSpanish"))),
10 new Document("$limit", 3));
11
12 ArrayList<Document> results = new ArrayList<>();
13 collection.aggregate(pipeline).into(results);
14 return results;
15}
Neste tutorial, como usamos duas collections diferentes, as passamos como parâmetros nos métodos do Atlas Search.
Para isso, execute a chamada de API como:
1GET http://localhost:8080/search/withSpanish?query={Raton Inalambrico}
e isso lhe daria a saída como
1[
2 {
3 "_id": {
4 "timestamp": 1723024731,
5 "date": "2024-08-07T09:58:51.000+00:00"
6 },
7 "productID": "ELEC-00123",
8 "productName": "Wireless Mouse",
9 "productNameSpanish": "Ratón Inalámbrico",
10 "category": "Electronics",
11 "price": 25.99,
12 "availability": "In Stock",
13 "productLink": "https://www.amazon.com/dp/B08J2T6P7Q",
14 "location": {
15 "city": "Shenzhen",
16 "coordinates": [
17 114.0579,
18 22.5431
19 ]
20 }
21 },
22 {
23 "_id": {
24 "timestamp": 1723024731,
25 "date": "2024-08-07T09:58:51.000+00:00"
26 },
27 "productID": "CHRG-11111",
28 "productName": "Wireless Charger",
29 "productNameSpanish": "Cargador Inalámbrico",
30 "category": "Accessories",
31 "price": 24.99,
32 "availability": "In Stock",
33 "productLink": "https://www.target.com/p/wireless-charger/-/A-87654321",
34 "location": {
35 "city": "Shenzhen",
36 "coordinates": [
37 114.0579,
38 22.5431
39 ]
40 }
41 }
42]

Caso 2: Desenvolver analisadores customizados

Em tutoriais anteriores, exploramos os analisadores predefinidos do Atlas e seus casos de uso. Além desses, o Atlas Search também permite que você crie analisadores personalizados, o que pode ser particularmente útil quando você precisar usar o Atlas Search para dados como IDs de produtos contendo caracteres alfanuméricos e hífens ou endereços de e-mail.
Neste tutorial, construiremos analisadores personalizados para dois campos diferentes e demonstraremos como realizar pesquisas usando os índices que criamos.
Por exemplo, nos dados de amostra que você importou, o campo_productDetails_ contém um _productID_ com um valor como **ELEC-00123**. Para efetivamente Atlas Search dentro deste campo, configuramos o índice da seguinte maneira:
1{
2 "mappings": {
3 "dynamic": true
4 },
5 "analyzers": [
6 {
7 "name": "productIDAnalyzer",
8 "tokenFilters": [
9 {
10 "type": "lowercase"
11 }
12 ],
13 "tokenizer": {
14 "pattern": "[-.]+",
15 "type": "regexSplit"
16 }
17 },
18 {
19 "name": "productLinkAnalyzer",
20 "tokenFilters": [
21 {
22 "type": "lowercase"
23 },
24 {
25 "originalTokens": "include",
26 "type": "asciiFolding"
27 }
28 ],
29 "tokenizer": {
30 "pattern": "\\W+",
31 "type": "regexSplit"
32 }
33 }
34 ]
35}
Para pesquisar o produtoID, podemos especificar apenas o numérico ou os alfabetos para realizar a pesquisa. O método Spring Boot para realizar a pesquisa seria assim:
1public List<Document> withCustomAnalyzersOnProductID(String query, String sampleProducts) {
2 MongoCollection<Document> collection;
3 MongoDatabase database = mongoTemplate.getDb();
4 collection = database.getCollection(sampleProducts);
5 List<Document> pipeline = Arrays.asList(new Document("$search",
6 new Document("index", "index02")
7 .append("text",
8 new Document("query", query)
9 .append("path", "productID"))),
10 new Document("$project",
11 new Document("_id", 0L)
12 .append("productID", 1L)
13 .append("productName", 1L)),
14 new Document("$limit", 3));
15
16 ArrayList<Document> results = new ArrayList<>();
17 collection.aggregate(pipeline).into(results);
18 return results;
19 }
A chamada REST seria parecida com a seguinte:
1GET http://localhost:8080/search/withCustomAnalyzersOnProductID?query={05050}
e isso lhe daria resultados como:
1[
2 {
3 "productID": "WEAR-05050",
4 "productName": "Smartwatch"
5 }
6]
No índice acima, também temos um analisador criado no campo// produtoLink que usa o regex nos links que estão sendo usados. Esse regex removeria o " " do texto e permitiria que você pesquisasse sem usar esses caracteres especiais.
Por exemplo, se você quiser pesquisar todos os produtos listados em http://www.amazon.com, o analisador personalizado o auxiliará a pesquisar os produtos.
Por exemplo, se tivermos a função Atlas Search como:
1public List<Document> withCustomAnalyzersOnProductLink(String query, String sampleProducts) {
2 MongoCollection<Document> collection;
3 MongoDatabase database = mongoTemplate.getDb();
4 collection = database.getCollection(sampleProducts);
5 List<Document> pipeline = Arrays.asList(new Document("$search",
6 new Document("index", "index02")
7 .append("text",
8 new Document("query", query)
9 .append("path", "productLink"))),
10 new Document("$project",
11 new Document("_id", 0L)
12 .append("productID", 1L)
13 .append("productName", 1L)
14 .append("productLink", 1L)),
15 new Document("$limit", 3));
16
17 ArrayList<Document> results = new ArrayList<>();
18 collection.aggregate(pipeline).into(results);
19 return results;
20}
Podemos usar a chamada REST como:
1GET http://localhost:8080/search/withCustomAnalyzerOnProductLink?query={www.amazon.com}
e resultaria como:
1[
2 {
3 "productID": "ELEC-00123",
4 "productName": "Wireless Mouse",
5 "productLink": "https://www.amazon.com/dp/B08J2T6P7Q"
6 },
7 {
8 "productID": "MONI-03030",
9 "productName": "4K Monitor",
10 "productLink": "https://www.amazon.com/dp/B09ABCDEFG"
11 },
12 {
13 "productID": "ACC-08080",
14 "productName": "Smartphone Stand",
15 "productLink": "https://www.amazon.com/dp/B08ABC1234"
16 }
17]

Caso 3: Executando uma Atlas Search com pesquisas

Ao usar o operador $search, espera-se sempre usá-lo como o primeiro estágio no pipeline. Mas se você se encontrar em uma situação em que precise primeiro realizar a união e depois o Atlas Search, o que você faria? Bem, este caso abrange o conceito!
Quando você importou os dados para o cluster do Atlas, você também teria importado o produtoReviews.json que contém avaliações para os produtos.
Para entender melhor, vamos criar um índice simples na collection produtoReviews:
1{
2 "mappings": {
3 "dynamic": true
4 }
5}
E suponha que você deseja obter todas as informações do produto de ambas as coleções que têm avaliações como _excelente. _
O método seria parecido com:
1public List<Document> searchWithLookups(String query, String productReviews) {
2 MongoCollection<Document> collection;
3 MongoDatabase database = mongoTemplate.getDb();
4 collection = database.getCollection(productReviews);
5 List<Document> pipeline = Arrays.asList(new Document("$lookup",
6 new Document("from", productReviews)
7 .append("localField", "productID")
8 .append("foreignField", "productID")
9 .append("as", "result")
10 .append("pipeline", Arrays.asList(new Document("$search",
11 new Document("index", "index03")
12 .append("text",
13 new Document("query", query)
14 .append("path", "review")))))),
15 new Document("$match",
16 new Document("result",
17 new Document("$ne", Arrays.asList()))),
18 new Document("$limit", 3));
19
20 ArrayList<Document> results = new ArrayList<>();
21 collection.aggregate(pipeline).into(results);
22 return results;
23}
A chamada REST API seria parecida com:
1GET http://localhost:8080/search/withLookups?query={excellent}
e isso resultaria em
1[
2{
3 "_id": {
4 "timestamp": 2008237403,
5 "date": "2033-08-21T11:43:23.000+00:00"
6 },
7 "productID": "ELEC-00123",
8 "review": "The Wireless Mouse is excellent with a long-lasting battery, perfect for daily use.",
9 "rating": 4.5,
10 "reviewer": "Alice Walker",
11 "reviewDate": "2024-08-01T10:00:00.000+00:00",
12 "result": [
13 {
14 "_id": {
15 "timestamp": 2008237403,
16 "date": "2033-08-21T11:43:23.000+00:00"
17 },
18 "productID": "ELEC-00123",
19 "review": "The Wireless Mouse is excellent with a long-lasting battery, perfect for daily use.",
20 "rating": 4.5,
21 "reviewer": "Alice Walker",
22 "reviewDate": "2024-08-01T10:00:00.000+00:00"
23 }
24 ]
25 },
26 {
27 "_id": {
28 "timestamp": 2008237403,
29 "date": "2033-08-21T11:43:23.000+00:00"
30 },
31 "productID": "HEAD-07070",
32 "review": "Noise Cancelling Headphones offer excellent sound isolation, though availability is limited.",
33 "rating": 4.5,
34 "reviewer": "Jack Taylor",
35 "reviewDate": "2024-08-10T19:00:00.000+00:00",
36 "result": [
37 {
38 "_id": {
39 "timestamp": 2008237403,
40 "date": "2033-08-21T11:43:23.000+00:00"
41 },
42 "productID": "HEAD-07070",
43 "review": "Noise Cancelling Headphones offer excellent sound isolation, though availability is limited.",
44 "rating": 4.5,
45 "reviewer": "Jack Taylor",
46 "reviewDate": "2024-08-10T19:00:00.000+00:00"
47 }
48 ]
49 },
50 {
51 "_id": {
52 "timestamp": 2008237403,
53 "date": "2033-08-21T11:43:23.000+00:00"
54 },
55 "productID": "MONI-03030",
56 "review": "The 4K Monitor delivers stunning visuals with excellent clarity, though it is on the pricier side.",
57 "rating": 4.7,
58 "reviewer": "Frank Harris",
59 "reviewDate": "2024-08-06T11:20:00.000+00:00",
60 "result": [
61 {
62 "_id": {
63 "timestamp": 2008237403,
64 "date": "2033-08-21T11:43:23.000+00:00"
65 },
66 "productID": "MONI-03030",
67 "review": "The 4K Monitor delivers stunning visuals with excellent clarity, though it is on the pricier side.",
68 "rating": 4.7,
69 "reviewer": "Frank Harris",
70 "reviewDate": "2024-08-06T11:20:00.000+00:00"
71 }
72 ]
73 }
74]
Isso forneceria todas as informações do produto com excelentes palavras-chave nas avaliações.

Conclusão

Nesta parte final da nossa série Atlas Search com Spring Boot, aprenderam os recursos mais avançados que o Atlas Search oferece, como analisadores personalizados e recursos específicos do Atlas Search. Ao explorar esses tópicos, expandimos a capacidade de projetar queries do Atlas Search poderosas e eficientes que atendem a necessidades complexas de recuperação de dados.
Discutimos analisadores personalizados para ajustar os resultados do Atlas Search e realizar pesquisas combinadas com outros estágios de agregação do MongoDB , como $lookup, para Enriquecer suas consultas com dados relacionados de várias coleções. Essas técnicas o ajudarão a criar soluções de Atlas Search mais nuançadas e eficazes, personalizadas para os requisitos específicos do seu aplicativo.
Se você tiver alguma dúvida sobre os artigos, siga o tópico do fórum da comunidade abaixo para perguntas e discussões. Além disso, continue explorando outros tutoriais em nosso centro de programadores do MongoDB.
Boa codificação!
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Parte de uma série
Atlas Search com inicialização de primavera
Mais nesta série
  • Introdução ao MongoDB Atlas Search e Java
  • Explorando recursos de pesquisa com o Atlas Search
Relacionado
Tutorial

Otimizando o desempenho de $lookup usando o poder da indexação


Aug 30, 2024 | 7 min read
Início rápido

Pipelines de agregação complexos com Baunilha PHP e MongoDB


Sep 05, 2024 | 10 min read
Podcast

Sugestões de esquema com Julia Openhein - Episódio 59 do podcast


Aug 09, 2024 | 13 min
Tutorial

Projetos de coleção única no MongoDB com dados Spring (Parte 2)


Aug 12, 2024 | 10 min read
Sumário
  • Pré-requisitos