Module io.github.bucket4j.core
Package io.github.bucket4j.distributed.proxy

Interface RemoteBucketBuilder<K>

  • Type Parameters:
    K - the type of keys in the external storage
    public interface RemoteBucketBuilder<K>
    The builder for BucketProxy
    See Also:
    ProxyManager

    • Method Detail

      • withRecoveryStrategy

        RemoteBucketBuilder<K> withRecoveryStrategy​(RecoveryStrategy recoveryStrategy)
        Configures custom recovery strategy instead of RecoveryStrategy.RECONSTRUCT that is used by default.
        Parameters:
        recoveryStrategy - specifies the reaction which should be applied in case of previously saved state of bucket has been lost, explicitly removed or expired.
        Returns:
        this

      • withOptimization

        RemoteBucketBuilder<K> withOptimization​(Optimization optimization)
        Configures the optimization strategy that will be applied for buckets that are built by this builder.

        It is worth mentioning that optimization will take effect only if you reuse the bucket, so you need to store a reference to the bucket anywhere in order to reuse it later. In other words, if any request optimization strategy has been applied to the bucket proxy then proxy can not be treated as a cheap object.

        * The full list of built-in optimizations can be found there Optimizations

        Parameters:
        optimization - optimization strategy
        Returns:
        this

      • withImplicitConfigurationReplacement

        RemoteBucketBuilder<K> withImplicitConfigurationReplacement​(long desiredConfigurationVersion,
                                                            TokensInheritanceStrategy tokensInheritanceStrategy)
        Activates implicit configuration replacement.

        By default distributed bucket operates with configuration that was provided at the time of its first creation. Providing the new configuration via RemoteBucketBuilder takes no effect if bucket is already persisted in the storage, because configuration is stored together with state of bucket. Without implicit configuration replacement, there is only one way to replace configuration of bucket - is explicit calling of Bucket.replaceConfiguration(BucketConfiguration, TokensInheritanceStrategy).

        When implicit configuration replacement is activated, bucket will automatically replace persisted configuration using provided tokensInheritanceStrategy in case of persisted version of configuration in the storage < than provided desiredConfigurationVersion.

        Parameters:
        desiredConfigurationVersion - specifies desired configuration version
        tokensInheritanceStrategy - the strategy that will be used for token migration if desiredConfigurationVersion of persisted bucket is less that provided desiredConfigurationVersion
        Returns:
        this

      • build

        BucketProxy build​(K key,
                  Supplier<BucketConfiguration> configurationSupplier)
        Has the same semantic with build(Object, BucketConfiguration), but additionally provides ability to provide configuration lazily, that can be helpful when figuring-out the right configuration parameters is costly, for example because parameters for particular key are stored in external database, configurationSupplier will be called if and only if bucket has not been persisted before.
        Parameters:
        key - the key that used in external storage to distinguish one bucket from another.
        configurationSupplier - provider for bucket configuration
        Returns:
        new instance of BucketProxy created in lazy mode.

      • build

        BucketProxy build​(K key,
                  BucketConfiguration configuration)
        Builds the BucketProxy. Proxy is being created in lazy mode, its state is not persisted in external storage until first interaction, so if you want to save bucket state immediately then just call Bucket.getAvailableTokens().

        If you had not used withOptimization(Optimization) during construction then created proxy can be treated as cheap object, feel free just build, use and forget as many proxies under the same key as you need, do not cache the built instances.

        Parameters:
        key - the key that used in external storage to distinguish one bucket from another.
        configuration - limits configuration
        Returns:
        new instance of BucketProxy created in lazy mode.