API de pesquisa de texto completo facetada Java usando o Atlas Search

1
git clone https://github.com/luketn/atlas-search-coco 
2
cd atlas-search-coco
3
docker compose up java-app

1
import java.util.Date;
2
import java.util.List;
3
4
public record Image(
5
       int _id,
6
       //The caption describes the contents of the image and can be searched on using full text search.
7
       String caption,
8
       String url,
9
       int height,
10
       int width,
11
       Date dateCaptured,
12
       String licenseName,
13
       String licenseUrl,
14
       //True if the image shows a person.
15
       boolean hasPerson,
16
       //Following fields are 'super categories'.
17
       // Each item in the list is a category.
18
       // One or more objects of each category listed is present in the image.
19
       List<String> accessory,
20
       List<String> animal,
21
       List<String> appliance,
22
       List<String> electronic,
23
       List<String> food,
24
       List<String> furniture,
25
       List<String> indoor,
26
       List<String> kitchen,
27
       List<String> outdoor,
28
       List<String> sports,
29
       List<String> vehicle
30
) { }

1
public record Category(
2
       int _id,
3
       String superCategory,
4
       String name
5
) { }

1
docker run -d --name mongodb-atlas -p 27017:27017 mongodb/mongodb-atlas-local:8.0.3

1
mongodb://localhost:27017/?directConnection=true

1
{
2
 "mappings": {
3
   "fields": {
4
     "caption": [{"type": "string"}],
5
     "hasPerson": {"type": "boolean"},
6
     "accessory": [{"type": "token"}, {"type": "stringFacet"}],
7
     "animal": [{"type": "token"}, {"type": "stringFacet"}],
8
     "appliance": [{"type": "token"}, {"type": "stringFacet"}],
9
     "electronic": [{"type": "token"}, {"type": "stringFacet"}],
10
     "food": [{"type": "token"}, {"type": "stringFacet"}],
11
     "furniture": [{"type": "token"}, {"type": "stringFacet"}],
12
     "indoor": [{"type": "token"}, {"type": "stringFacet"}],
13
     "kitchen": [{"type": "token"}, {"type": "stringFacet"}],
14
     "outdoor": [{"type": "token"}, {"type": "stringFacet"}],
15
     "sports": [{"type": "token"}, {"type": "stringFacet"}],
16
     "vehicle": [{"type": "token"}, {"type": "stringFacet"}]
17
   }
18
 }
19
}

1
     "caption": [{"type": "string"}],

1
     "hasPerson": {"type": "boolean"},

1
     "accessory": [{"type": "token"}, {"type": "stringFacet"}],
2
     "animal": [{"type": "token"}, {"type": "stringFacet"}],
3
     "appliance": [{"type": "token"}, {"type": "stringFacet"}],
4
     "electronic": [{"type": "token"}, {"type": "stringFacet"}],
5
     "food": [{"type": "token"}, {"type": "stringFacet"}],
6
     "furniture": [{"type": "token"}, {"type": "stringFacet"}],
7
     "indoor": [{"type": "token"}, {"type": "stringFacet"}],
8
     "kitchen": [{"type": "token"}, {"type": "stringFacet"}],
9
     "outdoor": [{"type": "token"}, {"type": "stringFacet"}],
10
     "sports": [{"type": "token"}, {"type": "stringFacet"}],
11
     "vehicle": [{"type": "token"}, {"type": "stringFacet"}]

1
    "animal": ["dog"]

1
[
2
 {
3
   $search: {
4
     facet: {
5
       operator: {
6
         compound: {
7
           filter: [
8
             {
9
               text: {
10
                 path: "caption",
11
                 query: "frisbee"
12
               }
13
             },
14
             {
15
               equals: {
16
                 path: "animal",
17
                 value: "dog"
18
               }
19
             }
20
           ]
21
         }
22
       },
23
       facets: {
24
         animal: {
25
           type: "string",
26
           path: "animal",
27
           numBuckets: 10
28
         },
29
         sports: {
30
           type: "string",
31
           path: "sports",
32
           numBuckets: 10
33
         }
34
       }
35
     },
36
     count: {
37
       type: "total"
38
     }
39
   }
40
 },
41
 {
42
   $facet: {
43
     docs: [],
44
     meta: [
45
       {
46
         $replaceWith: "$$SEARCH_META"
47
       },
48
       {
49
         $limit: 1
50
       }
51
     ]
52
   }
53
 }
54
]

1
{
2
 "docs": [
3
   {
4
     "_id": 394,
5
     "caption": "A dog is holding a frisbee standing on grass.",
6
     "url": "http://images.cocodataset.org/train2017/000000000394.jpg",
7
     "height": 611,
8
     "width": 640,
9
     "dateCaptured": {
10
       "$date": "2013-11-18T09:44:51.000Z"
11
     },
12
     "licenseName": "Attribution-NonCommercial-NoDerivs License",
13
     "licenseUrl": "http://creativecommons.org/licenses/by-nc-nd/2.0/",
14
     "hasPerson": false,
15
     "animal": [
16
       "dog"
17
     ],
18
     "sports": [
19
       "frisbee"
20
     ]
21
   },
22
   ...
23
 ],
24
 "meta": [
25
   {
26
     "count": {
27
       "total": {
28
         "$numberLong": "366"
29
       }
30
     },
31
     "facet": {
32
       "sports": {
33
         "buckets": [
34
           {
35
             "_id": "frisbee",
36
             "count": {
37
               "$numberLong": "364"
38
             }
39
           },
40
           {
41
             "_id": "sports ball",
42
             "count": {
43
               "$numberLong": "4"
44
             }
45
           },
46
           {
47
             "_id": "baseball glove",
48
             "count": {
49
               "$numberLong": "1"
50
             }
51
           }
52
         ]
53
       },
54
       "animal": {
55
         "buckets": [
56
           {
57
             "_id": "dog",
58
             "count": {
59
               "$numberLong": "366"
60
             }
61
           }
62
         ]
63
       }
64
     }
65
   }
66
 ]
67
}

1
<dependencies>
2
   <dependency>
3
       <groupId>org.mongodb</groupId>
4
       <artifactId>mongodb-driver-sync</artifactId>
5
       <version>5.2.0</version>
6
   </dependency>
7
   <dependency>
8
       <groupId>com.fasterxml.jackson.core</groupId>
9
       <artifactId>jackson-databind</artifactId>
10
       <version>2.17.2</version>
11
   </dependency>
12
   <dependency>
13
       <groupId>org.slf4j</groupId>
14
       <artifactId>slf4j-simple</artifactId>
15
       <version>2.0.13</version>
16
   </dependency>
17
</dependencies>

1
package com.mycodefu;
2
3
import com.fasterxml.jackson.databind.ObjectMapper;
4
import com.mongodb.client.MongoClient;
5
import com.mongodb.client.MongoClients;
6
import com.mongodb.client.MongoCollection;
7
import com.mongodb.client.MongoDatabase;
8
import com.sun.net.httpserver.HttpServer;
9
10
import java.io.IOException;
11
import java.net.InetSocketAddress;
12
import java.net.URLDecoder;
13
import java.nio.charset.StandardCharsets;
14
import java.util.ArrayList;
15
import java.util.Arrays;
16
import java.util.List;
17
import java.util.Map;
18
import java.util.stream.Collectors;
19
20
public class Main {
21
22
   public static void main(String[] args) throws IOException {
23
24
       String connectionString = "mongodb://localhost:27017";
25
       MongoClient mongoClient = MongoClients.create(connectionString);
26
       MongoDatabase database = mongoClient.getDatabase("atlasSearchCoco");
27
       MongoCollection<Category> categoryCollection = database.getCollection("category", Category.class);
28
       MongoCollection<Image> imageCollection = database.getCollection("image", Image.class);
29
30
       ObjectMapper objectMapper = new ObjectMapper();
31
32
       HttpServer httpServer = HttpServer.create(new InetSocketAddress("0.0.0.0", 8080), 0);
33
34
       httpServer.createContext("/categories", exchange -> {
35
           List<Category> categories = categoryCollection.find().into(new ArrayList<>());
36
           String categoriesJson = objectMapper.writeValueAsString(categories);
37
           byte[] categoriesJsonBytes = categoriesJson.getBytes();
38
39
           exchange.sendResponseHeaders(200, categoriesJsonBytes.length); 
40
           exchange.getResponseBody().write(categoriesJsonBytes);
41
           exchange.close();
42
       });
43
44
       httpServer.createContext("/images", exchange -> {
45
           Map<String, List<String>> params = Arrays.stream(exchange.getRequestURI().getQuery().split("&"))
46
                   .map(param -> param.split("=", 2))
47
                   .map(pair -> new String[]{
48
                           URLDecoder.decode(pair[0], StandardCharsets.UTF_8),
49
                           URLDecoder.decode(pair[1], StandardCharsets.UTF_8)
50
                   })
51
                   .collect(Collectors.groupingBy(
52
                           pair -> pair[0],
53
                           Collectors.mapping(
54
                                   pair -> pair[1],
55
                                   Collectors.toList()
56
                           )
57
                   ));
58
59
           //TODO: Implement the search for images based on the query parameters. For now we just return the first image.
60
           List<Image> images = imageCollection.find().limit(1).into(new ArrayList<>());
61
           //----------------
62
63
           String imagesJson = objectMapper.writeValueAsString(images);
64
           byte[] imagesJsonBytes = imagesJson.getBytes();
65
66
           exchange.sendResponseHeaders(200, imagesJsonBytes.length);
67
           exchange.getResponseBody().write(imagesJsonBytes);
68
           exchange.close();
69
       });
70
71
       httpServer.start();
72
73
       System.out.println("Server started on port http://localhost:8080");
74
       System.out.println("Try listing categories at http://localhost:8080/categories");
75
       System.out.println("Try searching for images at http://localhost:8080/images?caption=motorcycle");
76
   }
77
}

1
       String connectionString = "mongodb://localhost:27017";
2
       MongoClient mongoClient = MongoClients.create(connectionString);
3
       MongoDatabase database = mongoClient.getDatabase("atlasSearchCoco");
4
       MongoCollection<Category> categoryCollection = database.getCollection("category", Category.class);
5
       MongoCollection<Image> imageCollection = database.getCollection("image", Image.class);

1
       HttpServer httpServer = HttpServer.create(new InetSocketAddress("0.0.0.0", 8080), 0);
2
3
       httpServer.createContext("/categories", exchange -> {
4
           List<Category> categories = categoryCollection.find().into(new ArrayList<>());
5
           String categoriesJson = objectMapper.writeValueAsString(categories);
6
           byte[] categoriesJsonBytes = categoriesJson.getBytes();
7
8
           exchange.sendResponseHeaders(200, categoriesJsonBytes.length);
9
           exchange.getResponseBody().write(categoriesJsonBytes);
10
           exchange.close();
11
       });
12
…
13
       httpServer.start();

1
httpServer.createContext("/images", exchange -> {
2
   Map<String, List<String>> params = Arrays.stream(exchange.getRequestURI().getQuery().split("&"))
3
           .map(param -> param.split("=", 2))
4
           .map(pair -> new String[]{
5
                   URLDecoder.decode(pair[0], StandardCharsets.UTF_8),
6
                   URLDecoder.decode(pair[1], StandardCharsets.UTF_8)
7
           })
8
           .collect(Collectors.groupingBy(
9
                   pair -> pair[0],
10
                   Collectors.mapping(
11
                           pair -> pair[1],
12
                           Collectors.toList()
13
                   )
14
           ));
15
16
   //TODO: Implement the search for images based on the query parameters. For now we just return the first image.
17
   List<Image> images = imageCollection.find().limit(1).into(new ArrayList<>());
18
   //----------------
19
20
   String imagesJson = objectMapper.writeValueAsString(images);
21
   byte[] imagesJsonBytes = imagesJson.getBytes();
22
23
   exchange.sendResponseHeaders(200, imagesJsonBytes.length);
24
   exchange.getResponseBody().write(imagesJsonBytes);
25
   exchange.close();
26
});

1
import java.util.List;
2
3
public record ImageSearchResult(List<Image> docs, List<ImageMeta> meta) {
4
   public record ImageMeta (ImageMetaTotal count, ImageMetaFacets facet) { }
5
   public record ImageMetaTotal (long total) { }
6
   public record ImageMetaFacets (
7
           ImageMetaFacet accessory,
8
           ImageMetaFacet animal,
9
           ImageMetaFacet appliance,
10
           ImageMetaFacet electronic,
11
           ImageMetaFacet food,
12
           ImageMetaFacet furniture,
13
           ImageMetaFacet indoor,
14
           ImageMetaFacet kitchen,
15
           ImageMetaFacet outdoor,
16
           ImageMetaFacet sports,
17
           ImageMetaFacet vehicle
18
   ) { }
19
   public record ImageMetaFacet (List<ImageMetaFacetBucket> buckets) { }
20
   public record ImageMetaFacetBucket (String _id, long count) { }
21
}

1
private static ImageSearchResult search(MongoCollection<Image> imageCollection, String caption, Integer page, Boolean hasPerson, List<String> accessory, List<String> animal, List<String> appliance, List<String> electronic, List<String> food, List<String> furniture, List<String> indoor, List<String> kitchen, List<String> outdoor, List<String> sports, List<String> vehicle) {
2
   int skip = 0;
3
   int pageSize = 5;
4
   if (page != null) {
5
       skip = page * pageSize;
6
   }
7
8
9
   List<SearchOperator> clauses = new ArrayList<>();
10
   if (caption != null) {
11
       clauses.add(SearchOperator
12
               .text(
13
                       fieldPath("caption"),
14
                       caption
15
               )
16
       );
17
   }
18
   if (hasPerson != null) {
19
       clauses.add(equals("hasPerson", hasPerson));
20
   }
21
   BiConsumer<String, List<String>> addConditional = (String category, List<String> values) -> {
22
       if (values != null) {
23
           for (String value : values) {
24
               clauses.add(equals(category, value));
25
           }
26
       }
27
   };
28
   addConditional.accept("accessory", accessory);
29
   addConditional.accept("animal", animal);
30
   addConditional.accept("appliance", appliance);
31
   addConditional.accept("electronic", electronic);
32
   addConditional.accept("food", food);
33
   addConditional.accept("furniture", furniture);
34
   addConditional.accept("indoor", indoor);
35
   addConditional.accept("kitchen", kitchen);
36
   addConditional.accept("outdoor", outdoor);
37
   addConditional.accept("sports", sports);
38
   addConditional.accept("vehicle", vehicle);
39
40
   List<StringSearchFacet> facets = List.of(
41
           stringFacet("accessory", fieldPath("accessory")).numBuckets(10),
42
           stringFacet("animal", fieldPath("animal")).numBuckets(10),
43
           stringFacet("appliance", fieldPath("appliance")).numBuckets(10),
44
           stringFacet("electronic", fieldPath("electronic")).numBuckets(10),
45
           stringFacet("food", fieldPath("food")).numBuckets(10),
46
           stringFacet("furniture", fieldPath("furniture")).numBuckets(10),
47
           stringFacet("indoor", fieldPath("indoor")).numBuckets(10),
48
           stringFacet("kitchen", fieldPath("kitchen")).numBuckets(10),
49
           stringFacet("outdoor", fieldPath("outdoor")).numBuckets(10),
50
           stringFacet("sports", fieldPath("sports")).numBuckets(10),
51
           stringFacet("vehicle", fieldPath("vehicle")).numBuckets(10)
52
   );
53
54
55
   List<Bson> aggregateStages = List.of(
56
           Aggregates.search(
57
                   SearchCollector.facet(
58
                           SearchOperator.compound().filter(clauses),
59
                           facets
60
                   ), SearchOptions.searchOptions().count(SearchCount.total())),
61
           Aggregates.skip(skip),
62
           Aggregates.limit(pageSize),
63
           Aggregates.facet(
64
                   new Facet("docs", List.of()),
65
                   new Facet("meta", List.of(
66
                           Aggregates.replaceWith("$$SEARCH_META"),
67
                           Aggregates.limit(1)
68
                   ))
69
           )
70
   );
71
72
73
   ImageSearchResult imageSearchResult = imageCollection.aggregate(aggregateStages, ImageSearchResult.class).first();
74
75
76
   return imageSearchResult;
77
}
78
79
private static SearchOperator equals(String fieldName, Object value) {
80
   return SearchOperator.of(
81
           new Document("equals", new Document()
82
                   .append("path", fieldName)
83
                   .append("value", value)
84
           ));
85
}

1
//TODO: Implement the search for images based on the query parameters. For now we just return the first image.
2
List<Image> images = imageCollection.find().limit(1).into(new ArrayList<>());
3
//----------------

1
ImageSearchResult images = search(imageCollection,
2
       params.containsKey("caption") ? params.get("caption").getFirst() : null,
3
       params.containsKey("page") ? Integer.parseInt(params.get("page").getFirst()) : null,
4
       params.containsKey("hasPerson") ? Boolean.parseBoolean(params.get("hasPerson").getFirst()) : null,
5
       params.get("accessory"),
6
       params.get("animal"),
7
       params.get("appliance"),
8
       params.get("electronic"),
9
       params.get("food"),
10
       params.get("furniture"),
11
       params.get("indoor"),
12
       params.get("kitchen"),
13
       params.get("outdoor"),
14
       params.get("sports"),
15
       params.get("vehicle")
16
);

1
[
2
 {
3
   $search: {
4
     facet: {
5
       operator: {
6
         compound: {
7
           filter: [ <Filter clauses go here!> ]
8
         }
9
       },
10
       facets: { <List the facets we want returned> }
11
     }
12
   }
13
 }, 
14
 <Paging>
15
 {"$skip": 0},{"$limit": 5},
16
 <Return structure - page of docs + meta (facet counts)>
17
 {$facet: {docs: [], meta: [...]}}
18
]

1
   int skip = 0;
2
   int pageSize = 5;
3
   if (page != null) {
4
       skip = page * pageSize;
5
   }

1
   List<SearchOperator> clauses = new ArrayList<>();
2
   if (caption != null) {
3
       clauses.add(SearchOperator
4
               .text(
5
                       fieldPath("caption"),
6
                       caption
7
               )
8
       );
9
   }
10
   if (hasPerson != null) {
11
       clauses.add(equals("hasPerson", hasPerson));
12
   }
13
   BiConsumer<String, List<String>> addConditional = (String category, List<String> values) -> {
14
       if (values != null) {
15
           for (String value : values) {
16
               clauses.add(equals(category, value));
17
           }
18
       }
19
   };
20
   addConditional.accept("accessory", accessory);
21
   addConditional.accept("animal", animal);
22
   addConditional.accept("appliance", appliance);
23
   addConditional.accept("electronic", electronic);
24
   addConditional.accept("food", food);
25
   addConditional.accept("furniture", furniture);
26
   addConditional.accept("indoor", indoor);
27
   addConditional.accept("kitchen", kitchen);
28
   addConditional.accept("outdoor", outdoor);
29
   addConditional.accept("sports", sports);
30
   addConditional.accept("vehicle", vehicle);

1
   List<StringSearchFacet> facets = List.of(
2
           stringFacet("accessory", fieldPath("accessory")).numBuckets(10),
3
           stringFacet("animal", fieldPath("animal")).numBuckets(10),
4
           stringFacet("appliance", fieldPath("appliance")).numBuckets(10),
5
           stringFacet("electronic", fieldPath("electronic")).numBuckets(10),
6
           stringFacet("food", fieldPath("food")).numBuckets(10),
7
           stringFacet("furniture", fieldPath("furniture")).numBuckets(10),
8
           stringFacet("indoor", fieldPath("indoor")).numBuckets(10),
9
           stringFacet("kitchen", fieldPath("kitchen")).numBuckets(10),
10
           stringFacet("outdoor", fieldPath("outdoor")).numBuckets(10),
11
           stringFacet("sports", fieldPath("sports")).numBuckets(10),
12
           stringFacet("vehicle", fieldPath("vehicle")).numBuckets(10)
13
   );

1
List<Bson> aggregateStages = List.of(
2
       Aggregates.search(
3
               SearchCollector.facet(
4
                       SearchOperator.compound().filter(clauses),
5
                       facets
6
               ), SearchOptions.searchOptions().count(SearchCount.total())),
7
       Aggregates.skip(skip),
8
       Aggregates.limit(pageSize),
9
       Aggregates.facet(
10
               new Facet("docs", List.of()),
11
               new Facet("meta", List.of(
12
                       Aggregates.replaceWith("$$SEARCH_META"),
13
                       Aggregates.limit(1)
14
               ))
15
       )
16
);
17
18
ImageSearchResult imageSearchResult = imageCollection.aggregate(aggregateStages, ImageSearchResult.class).first();
19
return imageSearchResult;