Descubra seu Airbnb ideal: implementando um Spring Boot e Atlas Search com o driver Kotlin Sync

1
[
2
  {
3
    $search: {
4
      index: "searchPlaces",
5
      compound: {
6
        filter: [
7
          {
8
            range: {
9
              path: "number_of_reviews",
10
              gte: 50
11
            }
12
          },
13
          {
14
            text: {
15
              path: "summary",
16
              query: "Istambun",
17
              fuzzy: {
18
                maxEdits: 2
19
              }
20
            }
21
          }
22
        ]
23
      }
24
    }
25
  },
26
  {
27
    $limit: 5
28
  },
29
  {
30
    $project: {
31
      _id: 0,
32
      name: 1,
33
      summary: 1,
34
      number_of_reviews: 1,
35
      price: 1,    
36
      street: "$address.street",
37
    }
38
  }
39
]

1
dependencies {
2
 implementation("org.mongodb:mongodb-driver-kotlin-sync:5.1.1")
3
} 

1
spring.application.name=Airbnb Searcher
2
spring.data.mongodb.uri=mongodb+srv://user:pass@cluster0.cluster.mongodb.net/
3
spring.data.mongodb.database=sample_airbnb

1
package com.mongodb.searcher.application.config
2
3
import com.mongodb.kotlin.client.MongoClient
4
import com.mongodb.kotlin.client.MongoDatabase
5
import org.springframework.beans.factory.annotation.Value
6
import org.springframework.context.annotation.Bean
7
import org.springframework.context.annotation.Configuration
8
9
@Configuration
10
class MongoConfig {
11
12
   @Value("\${spring.data.mongodb.uri}")
13
   lateinit var uri: String
14
15
   @Value("\${spring.data.mongodb.database}")
16
   lateinit var databaseName: String
17
18
   @Bean
19
   fun getMongoClient(): MongoClient {
20
       return MongoClient.create(uri)
21
   }
22
23
   @Bean
24
   fun mongoDatabase(mongoClient: MongoClient): MongoDatabase {
25
       return mongoClient.getDatabase(databaseName)
26
   }
27
}

1
package com.mongodb.searcher.resources
2
3
import com.mongodb.searcher.domain.Airbnb
4
import org.bson.codecs.pojo.annotations.BsonId
5
import org.bson.codecs.pojo.annotations.BsonProperty
6
import org.bson.types.Decimal128
7
8
data class AirbnbEntity(
9
   @BsonId val id: String,
10
   val name: String,
11
   val summary: String,
12
   val price: Decimal128,
13
   @BsonProperty("number_of_reviews")
14
   val numbersOfReviews: Int,
15
   val address: Address
16
) {
17
   data class Address(
18
       val street: String,
19
       val country: String,
20
       @BsonProperty("country_code")
21
       val countryCode: String
22
   )
23
24
   fun toDomain(): Airbnb {
25
       return Airbnb(
26
           id = id,
27
           name = name,
28
           summary = summary,
29
           price = price,
30
           numbersOfReviews = numbersOfReviews,
31
           street = address.street
32
       )
33
   }
34
}

1
package com.mongodb.searcher.resources
2
3
import com.mongodb.client.model.Aggregates
4
import com.mongodb.client.model.Projections
5
import com.mongodb.client.model.search.FuzzySearchOptions
6
import com.mongodb.client.model.search.SearchOperator
7
import com.mongodb.client.model.search.SearchOptions
8
import com.mongodb.client.model.search.SearchPath
9
import com.mongodb.kotlin.client.MongoDatabase
10
import org.slf4j.LoggerFactory
11
import org.springframework.stereotype.Repository
12
13
@Repository
14
class AirbnbRepository(
15
   private val mongoDatabase: MongoDatabase
16
) {
17
   companion object {
18
       private val logger = LoggerFactory.getLogger(AirbnbRepository::class.java)
19
       private const val COLLECTION = "listingsAndReviews"
20
   }
21
   fun find(query: String, minNumberReviews: Int): List<AirbnbEntity> {
22
       val collection = mongoDatabase.getCollection<AirbnbEntity>(COLLECTION)
23
24
       return try {
25
           collection.aggregate(
26
               listOf(
27
                   createSearchStage(query, minNumberReviews),
28
                   createLimitStage(),
29
                   createProjectionStage()
30
               )
31
           ).toList()
32
       } catch (e: Exception) {
33
           logger.error("An exception occurred when trying to aggregate the collection: ${e.message}")
34
           emptyList()
35
       }
36
   }
37
38
   private fun createSearchStage(query: String, minNumberReviews: Int) =
39
       Aggregates.search(
40
           SearchOperator.compound().filter(
41
               listOf(
42
                   SearchOperator.numberRange(SearchPath.fieldPath("number_of_reviews"))
43
                       .gte(minNumberReviews),
44
                   SearchOperator.text(SearchPath.fieldPath(AirbnbEntity::summary.name), query)
45
                       .fuzzy(FuzzySearchOptions.fuzzySearchOptions().maxEdits(2))
46
               )
47
           ),
48
           SearchOptions.searchOptions().index("searchPlaces")
49
       )
50
   private fun createLimitStage() =
51
       Aggregates.limit(5)
52
53
54
   private fun createProjectionStage() =
55
       Aggregates.project(
56
           Projections.fields(
57
               Projections.include(
58
                   listOf(
59
                       AirbnbEntity::name.name,
60
                       AirbnbEntity::id.name,
61
                       AirbnbEntity::summary.name,
62
                       AirbnbEntity::price.name,
63
                       "number_of_reviews",
64
                       AirbnbEntity::address.name
65
                   )
66
               )
67
           )
68
       )
69
}

1
package com.mongodb.searcher.domain
2
3
import org.bson.codecs.pojo.annotations.BsonId
4
import org.bson.codecs.pojo.annotations.BsonProperty
5
import org.bson.types.Decimal128
6
7
data class Airbnb(
8
   @BsonId val id: String,
9
   val name: String,
10
   val summary: String,
11
   val price: Decimal128,
12
   @BsonProperty("number_of_reviews")
13
   val numbersOfReviews: Int,
14
   val street: String
15
)

1
package com.mongodb.searcher.domain
2
3
import com.mongodb.searcher.resources.AirbnbRepository
4
import org.springframework.stereotype.Service
5
6
@Service
7
class AirbnbService(
8
   private val airbnbRepository: AirbnbRepository
9
) {
10
11
   fun find(query: String, minNumberReviews: Int): List<Airbnb> {
12
       require(query.isNotEmpty()) { "Query must not be empty" }
13
       require(minNumberReviews > 0) { "Minimum number of reviews must not be negative" }
14
15
      return airbnbRepository.find(query, minNumberReviews).map { it.toDomain() }
16
   }
17
}

1
package com.mongodb.searcher.application.web
2
3
import com.mongodb.searcher.domain.Airbnb
4
import com.mongodb.searcher.domain.AirbnbService
5
import org.springframework.web.bind.annotation.GetMapping
6
import org.springframework.web.bind.annotation.RequestParam
7
import org.springframework.web.bind.annotation.RestController
8
9
@RestController
10
class AirbnbController(
11
   private val airbnbService: AirbnbService
12
) {
13
14
   @GetMapping("/airbnb/search")
15
   fun find(
16
       @RequestParam("query") query: String,
17
       @RequestParam("minNumberReviews") minNumberReviews: Int
18
   ): List<Airbnb> {
19
       return airbnbService.find(query, minNumberReviews)
20
   }
21
}

1
./gradlew bootRun

1
curl --location 'http://localhost:8080/airbnb/search?query=Istambun&minNumberReviews=50'