What it's Like to Migrate a Backend Service From Spring Boot to Vert.X

@Component
@Path("scanner")
class ScannerEndpoints {
  // See below
  @Autowired
  private lateinit var scansService: ScansService

  @POST
  @Path("scan")
  @Produces("application/json")
  @Consumes("text/plain")
  fun processScan(barocde: String) {
    val location = determineLocationFromRequest()
    return scansService.processScan(barcode, location)
  }
}

@Service
class ScanService {
  @Autowired
  private lateinit var scansRepository: ScansRepository

  fun processScan(ticketBarcode: String, location: Location): ScanRecord {
    // Step #1: Determine the scan outcome 
    val scanRecord = evaluateScan(ticketBarcode, location)
    // Step #2: Save the outcome
    scansRepository.saveScan(scanRecord)
    return scanRecord
  }
    
  private fun evaluateScan(ticketBarcode: String, location: Location): ScanRecord {
    val ticket = parseTicketBarcode(ticketBarcode)
    val rules = location.determineRulesApplicableToTicket(ticket)
    for (rule in rules) {
      val previousScans = scansRepository.findAllApplicableToRule(rule)
      // We have success
      if (rule.evaluate(ticket, previousScans)) {
          return ScanRecord.accepted(/* scan details here */)
      }
    }
    // Nothing succeeded
    return ScanRecord.rejected(/* scan details here */)
  } 
}

class ScanningVerticle(val pool: JDBCPool) : AbstractVerticle() {
  private val objectMapper = jacksonObjectMapper()

  override fun start(startPromise: Promise<Void>) {
    val router = Router.router(vertx)
    
    // Configure the HTTP routing
    router
      .post("/scan")
      .consumes("text/plain")
      .produces("application/json")
      .handler { ctx ->
        val response = ctx.response()
        ctx.request().body { requestBody ->
          // Omitted: check that the requestBody extraction was successful

          val location = determineLocationFromRequest()
          val logic = ConsumptionLogic(location, pool)

          val barcode = requestBody.result().toString()
          logic
            // Step #1: Determine the scan outcome
            .evaluateScan(barcode)
            .onFailure { response.setStatusCode(500).end("Unexpected failure") }
            .onComplete { result ->
              val scanRecord = result.result()
              // Step #2: Save the outcome
              logic.saveScan(scanRecord)
                .onFailure { response.setStatusCode(500).end("Unexpected failure") }
                .onComplete { response.end(objectMapper.writeValueAsString(scanRecord)) }
            }
        }
      }
    
    // Start the Vert.x HTTP server
    vertx
      .createHttpServer()
      .requestHandler(router)
      .listen(8080) { http ->
          if (http.succeeded()) {
              startPromise.complete()
              println("HTTP server started on port 8080")
          } else {
              startPromise.fail(http.cause());
          }
      }
  }
}

data class RuleEvaluation(
    val rule: Rule,
    val success: Boolean
)

class ConsumptionLogic(val location: Location, val pool: JDBCPool) {
  fun evaluateScan(barcode: String): Future<ScanRecord> {
    val promise = Promise.promise<ScanRecord>()
    val ticket = parseTicketBarcode(ticketBarcode)
    val rules = location.determineRulesApplicableToTicket(ticket)

    CompositeFuture
      // Wait on all rules to evaluate
      .all(rules.map { rule -> evaluateRule(ticket, rule)})
      .onFailure { promise.fail(it) }
      .onComplete { result ->
        val ruleEvaluations = result.result().list<RuleEvaluation>()
        // Find the first rule with a successful outcome
        val firstMatch = ruleEvaluations.find { it.success }
        if (firstMatch != null) {
          promise.complete(ScanRecord.accepted(/* scan details here */))
        } else {
          // If a successful outcome doesn't exist in our results, then we reject the scan
          promise.complete(ScanRecord.rejected(/* scan details here */))
        }
      }
    return promise.future()
  }

  fun evaluateRule(ticket: Ticket, rule: Rule): Future<RuleEvaluation> {
    val promise = Promise.promise<RuleEvaluation>()
    val previousScansQuery = rule.buildPreviousScansQueryForTicket(ticket)
    pool
      .preparedQuery(previousScansQuery)
      .execute(/* Query parameters here */)
      .onFailure { promise.fail(it) }
      .onComplete { rows ->
        val previousScans = rows.result()
        promise.complete(RuleEvaluation(rule, rule.evaluate(ticket, previousScans)))
      }
    return promise.future()
  }

  fun saveScan(scanRecord: ScanRecord): Future<RowSet<Row>> {
    return pool
      .preparedQuery("INSERT INTO ...")
      .execute(/* Query parameters here */)
  }
}

fun main(args: Array<String>) {
  val vertx = Vertx.vertx()
  val pool = JDBCPool.pool(
      vertx,
      JDBCConnectOptions()
          .setJdbcUrl("jdbc:postgresql://localhost:5432/database")
          .setUser("database")
          .setPassword("database"),
      PoolOptions()
        .setMaxSize(16)
  )
  
  vertx.deployVerticle(ScanningVerticle(pool))
}