//將請求定義為命令 放入佇列中
const val MY_QUEUE_NAME: String = "myServiceQueue"

@Configuration
class MyServiceQueueConfiguration {

    @Bean(MY_QUEUE_NAME)
    fun myServiceQueue(commandExecutionQueueFactory: CommandExecutionQueueFactory) =
        commandExecutionQueueFactory.createQueue(
                MY_QUEUE_NAME,

                // optionally redefine part or totality of the default policy
                DEFAULT_EXECUTION_POLICY.copy(
                        concurrency = 4,
                        delayBeforeConsideringTask = Duration.ofSeconds(5),
                        maxRetriesBeforeQuarantine = 10,

                        // optional, none by default
                        rateLimits = RateLimits(
                                2300 executionsOver Duration.ofMinutes(15),
                                4500 executionsOver Duration.ofMinutes(30),
                                8800 executionsOver Duration.ofHours(1)
                        ),

                        // optional, none by default
                        circuitBreaking = CircuitBreaking(
                                failureRateThreshold = 0.5,
                                windowDuration = Duration.ofMinutes(10),
                                // will tell that some exceptions are to be considered as provider failures
                                considerExceptionAsFailureIf = someExceptionPredicate()
                        )
                ),

                // optional, a probe that will be queried to know whether to pause task consumption
                // (may query a feature flag, a state defined via some UI, etc.)
                somePauseProbe()
        )
}

class CommandQueue(...) {
    // ...
    
    override fun schedule(command: CommandSpecification) {
        // add task to queue, log details, emit metrics
        schedule(ScheduledTask(
                command,
                queueName,
                clock,
                // this is the important part for deduplication to work
                scheduledExecutionDate = executionPolicy.computeNextExecutionDate(clock, tries = 0)
        ), command.deduplicate)
    }

    // ...

    override fun processCommands(): Boolean {
        val circuitBreaker = circuitBreaker()
        if (circuitBreaker.isOpen()) {
            return false
        }

        val task = taskRepository.tryLockingTaskWithEarliestScheduleOlderThan(queueName, LocalDateTime.now(clock))
                ?: return false

        val command = commandRegistry.get(task.commandName)

        // each case: decides what to do with task, log details, emit metrics
        val executionResult = when {
            command == null -> commandNotFound(task)
            violatesRateLimit(task.weight) -> rateLimited(task)
            !running -> aborted(task)
            else -> executeCommand(command, task)
        }

        registerCall(circuitBreaker, executionResult)
        // remove task, or move it to quarantine, or update number of tries
        handleExecutionResult(executionResult)
        return executionResult.commandExecuted
    }
    
    // ...
}